Replace trait with enum in Rust

nenad1002 · nenad1002 · commit 4f74f4cbe201 · 2026-04-01T19:35:19.000Z
diff --git a/samples/rust/audio-transcription-example/src/main.rs b/samples/rust/audio-transcription-example/src/main.rs
@@ -35,10 +35,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     if !model.is_cached().await? {
         println!("Downloading model...");
         model
-            .download(Some(Box::new(|progress: &str| {
+            .download(Some(|progress: &str| {
                 print!("\r  {progress}%");
                 io::stdout().flush().ok();
-            })))
+            }))
             .await?;
         println!();
     }
diff --git a/samples/rust/foundry-local-webserver/src/main.rs b/samples/rust/foundry-local-webserver/src/main.rs
@@ -34,10 +34,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     if !model.is_cached().await? {
         print!("Downloading model {model_alias}...");
         model
-            .download(Some(Box::new(move |progress: &str| {
+            .download(Some(move |progress: &str| {
                 print!("\rDownloading model... {progress}%");
                 io::stdout().flush().ok();
-            })))
+            }))
             .await?;
         println!();
     }
diff --git a/samples/rust/native-chat-completions/src/main.rs b/samples/rust/native-chat-completions/src/main.rs
@@ -32,10 +32,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     if !model.is_cached().await? {
         println!("Downloading model...");
         model
-            .download(Some(Box::new(|progress: &str| {
+            .download(Some(|progress: &str| {
                 print!("\r  {progress}%");
                 io::stdout().flush().ok();
-            })))
+            }))
             .await?;
         println!();
     }
diff --git a/samples/rust/tool-calling-foundry-local/src/main.rs b/samples/rust/tool-calling-foundry-local/src/main.rs
@@ -66,10 +66,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     if !model.is_cached().await? {
         println!("Downloading model...");
         model
-            .download(Some(Box::new(|progress: &str| {
+            .download(Some(|progress: &str| {
                 print!("\r  {progress}%");
                 io::stdout().flush().ok();
-            })))
+            }))
             .await?;
         println!();
     }
diff --git a/samples/rust/tutorial-chat-assistant/src/main.rs b/samples/rust/tutorial-chat-assistant/src/main.rs
@@ -21,10 +21,10 @@ async fn main() -> anyhow::Result<()> {
     if !model.is_cached().await? {
         println!("Downloading model...");
         model
-            .download(Some(Box::new(|progress: &str| {
+            .download(Some(|progress: &str| {
                 print!("\r  {progress}");
                 io::stdout().flush().ok();
-            })))
+            }))
             .await?;
         println!();
     }
diff --git a/samples/rust/tutorial-document-summarizer/src/main.rs b/samples/rust/tutorial-document-summarizer/src/main.rs
@@ -96,10 +96,10 @@ async fn main() -> anyhow::Result<()> {
     if !model.is_cached().await? {
         println!("Downloading model...");
         model
-            .download(Some(Box::new(|progress: &str| {
+            .download(Some(|progress: &str| {
                 print!("\r  {progress}");
                 io::stdout().flush().ok();
-            })))
+            }))
             .await?;
         println!();
     }
diff --git a/samples/rust/tutorial-tool-calling/src/main.rs b/samples/rust/tutorial-tool-calling/src/main.rs
@@ -199,10 +199,10 @@ async fn main() -> anyhow::Result<()> {
     if !model.is_cached().await? {
         println!("Downloading model...");
         model
-            .download(Some(Box::new(|progress: &str| {
+            .download(Some(|progress: &str| {
                 print!("\r  {progress}");
                 io::stdout().flush().ok();
-            })))
+            }))
             .await?;
         println!();
     }
diff --git a/samples/rust/tutorial-voice-to-text/src/main.rs b/samples/rust/tutorial-voice-to-text/src/main.rs
@@ -28,10 +28,10 @@ async fn main() -> anyhow::Result<()> {
     if !speech_model.is_cached().await? {
         println!("Downloading speech model...");
         speech_model
-            .download(Some(Box::new(|progress: &str| {
+            .download(Some(|progress: &str| {
                 print!("\r  {progress}");
                 io::stdout().flush().ok();
-            })))
+            }))
             .await?;
         println!();
     }
@@ -60,10 +60,10 @@ async fn main() -> anyhow::Result<()> {
     if !chat_model.is_cached().await? {
         println!("Downloading chat model...");
         chat_model
-            .download(Some(Box::new(|progress: &str| {
+            .download(Some(|progress: &str| {
                 print!("\r  {progress}");
                 io::stdout().flush().ok();
-            })))
+            }))
             .await?;
         println!();
     }
diff --git a/sdk/rust/examples/chat_completion.rs b/sdk/rust/examples/chat_completion.rs
@@ -40,9 +40,9 @@ async fn main() -> Result<()> {
     if !model.is_cached().await? {
         println!("Downloading model '{}'…", model.alias());
         model
-            .download(Some(Box::new(|progress: &str| {
+            .download(Some(|progress: &str| {
                 println!("  {progress}");
-            })))
+            }))
             .await?;
     }
 
diff --git a/sdk/rust/examples/interactive_chat.rs b/sdk/rust/examples/interactive_chat.rs
@@ -41,7 +41,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Download if needed
     if !model.is_cached().await? {
         println!("Downloading '{alias}'…");
-        model.download(Some(Box::new(|p: &str| print!("\r  {p}%")))).await?;
+        model.download(Some(|p: &str| print!("\r  {p}%"))).await?;
         println!();
     }
 
diff --git a/sdk/rust/examples/tool_calling.rs b/sdk/rust/examples/tool_calling.rs
@@ -67,7 +67,7 @@ async fn main() -> Result<()> {
 
     if !model.is_cached().await? {
         println!("Downloading model '{}'…", model.alias());
-        model.download(Some(Box::new(|p: &str| println!("  {p}")))).await?;
+        model.download(Some(|p: &str| println!("  {p}"))).await?;
     }
     println!("Loading model '{}'…", model.alias());
     model.load().await?;
diff --git a/sdk/rust/src/catalog.rs b/sdk/rust/src/catalog.rs
@@ -8,7 +8,6 @@ use std::time::{Duration, Instant};
 use crate::detail::core_interop::CoreInterop;
 use crate::detail::ModelLoadManager;
 use crate::error::{FoundryLocalError, Result};
-use crate::imodel::IModel;
 use crate::detail::model::Model;
 use crate::detail::model_variant::ModelVariant;
 use crate::types::ModelInfo;
@@ -40,7 +39,7 @@ impl CacheInvalidator {
 /// All mutable catalog data behind a single lock to prevent split-brain reads.
 struct CatalogState {
     models_by_alias: HashMap<String, Arc<Model>>,
-    variants_by_id: HashMap<String, Arc<ModelVariant>>,
+    variants_by_id: HashMap<String, Arc<Model>>,
     last_refresh: Option<Instant>,
 }
 
@@ -125,20 +124,14 @@ impl Catalog {
     }
 
     /// Return all known models keyed by alias.
-    pub async fn get_models(&self) -> Result<Vec<Arc<dyn IModel>>> {
+    pub async fn get_models(&self) -> Result<Vec<Arc<Model>>> {
         self.update_models().await?;
         let s = self.lock_state()?;
-        Ok(s.models_by_alias
-            .values()
-            .map(|m| {
-                let model: Arc<dyn IModel> = m.clone();
-                model
-            })
-            .collect())
+        Ok(s.models_by_alias.values().cloned().collect())
     }
 
     /// Look up a model by its alias.
-    pub async fn get_model(&self, alias: &str) -> Result<Arc<dyn IModel>> {
+    pub async fn get_model(&self, alias: &str) -> Result<Arc<Model>> {
         if alias.trim().is_empty() {
             return Err(FoundryLocalError::Validation {
                 reason: "Model alias must be a non-empty string".into(),
@@ -148,10 +141,7 @@ impl Catalog {
         let s = self.lock_state()?;
         s.models_by_alias
             .get(alias)
-            .map(|m| {
-                let model: Arc<dyn IModel> = m.clone();
-                model
-            })
+            .cloned()
             .ok_or_else(|| {
                 let available: Vec<&str> = s.models_by_alias.keys().map(|k| k.as_str()).collect();
                 FoundryLocalError::ModelOperation {
@@ -162,10 +152,10 @@ impl Catalog {
 
     /// Look up a specific model variant by its unique id.
     ///
-    /// NOTE: This will return an `IModel` representing a single variant. Use
-    /// [`get_model`](Catalog::get_model) to obtain an `IModel` with all
+    /// NOTE: This will return a `Model` representing a single variant. Use
+    /// [`get_model`](Catalog::get_model) to obtain a `Model` with all
     /// available variants.
-    pub async fn get_model_variant(&self, id: &str) -> Result<Arc<dyn IModel>> {
+    pub async fn get_model_variant(&self, id: &str) -> Result<Arc<Model>> {
         if id.trim().is_empty() {
             return Err(FoundryLocalError::Validation {
                 reason: "Variant id must be a non-empty string".into(),
@@ -175,10 +165,7 @@ impl Catalog {
         let s = self.lock_state()?;
         s.variants_by_id
             .get(id)
-            .map(|v| {
-                let variant: Arc<dyn IModel> = v.clone();
-                variant
-            })
+            .cloned()
             .ok_or_else(|| {
                 let available: Vec<&str> = s.variants_by_id.keys().map(|k| k.as_str()).collect();
                 FoundryLocalError::ModelOperation {
@@ -188,7 +175,7 @@ impl Catalog {
     }
 
     /// Return only the model variants that are currently cached on disk.
-    pub async fn get_cached_models(&self) -> Result<Vec<Arc<dyn IModel>>> {
+    pub async fn get_cached_models(&self) -> Result<Vec<Arc<Model>>> {
         self.update_models().await?;
         let raw = self
             .core
@@ -201,37 +188,23 @@ impl Catalog {
         let s = self.lock_state()?;
         Ok(cached_ids
             .iter()
-            .filter_map(|id| {
-                s.variants_by_id
-                    .get(id)
-                    .map(|v| {
-                        let variant: Arc<dyn IModel> = v.clone();
-                        variant
-                    })
-            })
+            .filter_map(|id| s.variants_by_id.get(id).cloned())
             .collect())
     }
 
     /// Return model variants that are currently loaded into memory.
-    pub async fn get_loaded_models(&self) -> Result<Vec<Arc<dyn IModel>>> {
+    pub async fn get_loaded_models(&self) -> Result<Vec<Arc<Model>>> {
         self.update_models().await?;
         let loaded_ids = self.model_load_manager.list_loaded().await?;
         let s = self.lock_state()?;
         Ok(loaded_ids
             .iter()
-            .filter_map(|id| {
-                s.variants_by_id
-                    .get(id)
-                    .map(|v| {
-                        let variant: Arc<dyn IModel> = v.clone();
-                        variant
-                    })
-            })
+            .filter_map(|id| s.variants_by_id.get(id).cloned())
             .collect())
     }
 
     /// Resolve the latest catalog version for the provided model or variant.
-    pub async fn get_latest_version(&self, model_or_model_variant: &Arc<dyn IModel>) -> Result<Arc<dyn IModel>> {
+    pub async fn get_latest_version(&self, model_or_model_variant: &Arc<Model>) -> Result<Arc<Model>> {
         self.update_models().await?;
         let s = self.lock_state()?;
 
@@ -287,22 +260,22 @@ impl Catalog {
         };
 
         let mut alias_map_build: HashMap<String, Model> = HashMap::new();
-        let mut id_map: HashMap<String, Arc<ModelVariant>> = HashMap::new();
+        let mut id_map: HashMap<String, Arc<Model>> = HashMap::new();
 
         for info in infos {
             let id = info.id.clone();
             let alias = info.alias.clone();
-            let variant = Arc::new(ModelVariant::new(
+            let variant = ModelVariant::new(
                 info,
                 Arc::clone(&self.core),
                 Arc::clone(&self.model_load_manager),
                 self.invalidator.clone(),
-            ));
-            id_map.insert(id, Arc::clone(&variant));
+            );
+            id_map.insert(id, Arc::new(Model::from_variant(variant.clone())));
 
             alias_map_build
                 .entry(alias)
-                .or_insert_with_key(|a| Model::new(a.clone(), Arc::clone(&self.core)))
+                .or_insert_with_key(|a| Model::from_group(a.clone(), Arc::clone(&self.core)))
                 .add_variant(variant);
         }
 
diff --git a/sdk/rust/src/detail/model.rs b/sdk/rust/src/detail/model.rs
diff --git a/sdk/rust/src/detail/model_variant.rs b/sdk/rust/src/detail/model_variant.rs
diff --git a/sdk/rust/src/imodel.rs b/sdk/rust/src/imodel.rs
diff --git a/sdk/rust/src/lib.rs b/sdk/rust/src/lib.rs
diff --git a/sdk/rust/tests/integration/model_test.rs b/sdk/rust/tests/integration/model_test.rs

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {`
`41`	`41`	`// Download if needed`
`42`	`42`	`if !model.is_cached().await? {`
`43`	`43`	`println!("Downloading '{alias}'…");`
`44`		`- model.download(Some(Box::new(\|p: &str\| print!("\r {p}%")))).await?;`
	`44`	`+ model.download(Some(\|p: &str\| print!("\r {p}%"))).await?;`
`45`	`45`	`println!();`
`46`	`46`	`}`
`47`	`47`