rust sdk: change download progress callback from &str to f64 (#608)

samuel100 · Copilot · web-flow · commit 23477c8d375e · 2026-04-08T12:14:18.000-07:00
Change the public download progress callback type from FnMut(&amp;str) to
FnMut(f64) for cross-SDK consistency. Python, JS, and C# SDKs all expose
a numeric float type for download progress.

The string-to-float parsing now happens inside model_variant.rs (using
chunk.parse::&lt;f64&gt;()), matching the pattern already used by
download_and_register_eps_with_progress. Unparseable chunks are silently
TryParse). The internal core_interop streaming infrastructure remains
unchanged since it is shared with chat/audio streaming.

---------

Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;
diff --git a/samples/rust/.cargo/config.toml b/samples/rust/.cargo/config.toml
diff --git a/samples/rust/audio-transcription-example/src/main.rs b/samples/rust/audio-transcription-example/src/main.rs
@@ -35,8 +35,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     if !model.is_cached().await? {
         println!("Downloading model...");
         model
-            .download(Some(|progress: &str| {
-                print!("\r  {progress}%");
+            .download(Some(|progress: f64| {
+                print!("\r  {progress:.1}%");
                 io::stdout().flush().ok();
             }))
             .await?;
diff --git a/samples/rust/foundry-local-webserver/src/main.rs b/samples/rust/foundry-local-webserver/src/main.rs
@@ -34,8 +34,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     if !model.is_cached().await? {
         print!("Downloading model {model_alias}...");
         model
-            .download(Some(move |progress: &str| {
-                print!("\rDownloading model... {progress}%");
+            .download(Some(move |progress: f64| {
+                print!("\rDownloading model... {progress:.1}%");
                 io::stdout().flush().ok();
             }))
             .await?;
diff --git a/samples/rust/native-chat-completions/src/main.rs b/samples/rust/native-chat-completions/src/main.rs
@@ -32,8 +32,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     if !model.is_cached().await? {
         println!("Downloading model...");
         model
-            .download(Some(|progress: &str| {
-                print!("\r  {progress}%");
+            .download(Some(|progress: f64| {
+                print!("\r  {progress:.1}%");
                 io::stdout().flush().ok();
             }))
             .await?;
diff --git a/samples/rust/tool-calling-foundry-local/src/main.rs b/samples/rust/tool-calling-foundry-local/src/main.rs
@@ -66,8 +66,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     if !model.is_cached().await? {
         println!("Downloading model...");
         model
-            .download(Some(|progress: &str| {
-                print!("\r  {progress}%");
+            .download(Some(|progress: f64| {
+                print!("\r  {progress:.1}%");
                 io::stdout().flush().ok();
             }))
             .await?;
diff --git a/samples/rust/tutorial-chat-assistant/src/main.rs b/samples/rust/tutorial-chat-assistant/src/main.rs
@@ -21,8 +21,8 @@ async fn main() -> anyhow::Result<()> {
     if !model.is_cached().await? {
         println!("Downloading model...");
         model
-            .download(Some(|progress: &str| {
-                print!("\r  {progress}");
+            .download(Some(|progress: f64| {
+                print!("\r  {progress:.1}%");
                 io::stdout().flush().ok();
             }))
             .await?;
diff --git a/samples/rust/tutorial-document-summarizer/src/main.rs b/samples/rust/tutorial-document-summarizer/src/main.rs
@@ -96,8 +96,8 @@ async fn main() -> anyhow::Result<()> {
     if !model.is_cached().await? {
         println!("Downloading model...");
         model
-            .download(Some(|progress: &str| {
-                print!("\r  {progress}");
+            .download(Some(|progress: f64| {
+                print!("\r  {progress:.1}%");
                 io::stdout().flush().ok();
             }))
             .await?;
diff --git a/samples/rust/tutorial-tool-calling/src/main.rs b/samples/rust/tutorial-tool-calling/src/main.rs
@@ -199,8 +199,8 @@ async fn main() -> anyhow::Result<()> {
     if !model.is_cached().await? {
         println!("Downloading model...");
         model
-            .download(Some(|progress: &str| {
-                print!("\r  {progress}");
+            .download(Some(|progress: f64| {
+                print!("\r  {progress:.1}%");
                 io::stdout().flush().ok();
             }))
             .await?;
diff --git a/samples/rust/tutorial-voice-to-text/src/main.rs b/samples/rust/tutorial-voice-to-text/src/main.rs
@@ -28,8 +28,8 @@ async fn main() -> anyhow::Result<()> {
     if !speech_model.is_cached().await? {
         println!("Downloading speech model...");
         speech_model
-            .download(Some(|progress: &str| {
-                print!("\r  {progress}");
+            .download(Some(|progress: f64| {
+                print!("\r  {progress:.1}%");
                 io::stdout().flush().ok();
             }))
             .await?;
@@ -60,8 +60,8 @@ async fn main() -> anyhow::Result<()> {
     if !chat_model.is_cached().await? {
         println!("Downloading chat model...");
         chat_model
-            .download(Some(|progress: &str| {
-                print!("\r  {progress}");
+            .download(Some(|progress: f64| {
+                print!("\r  {progress:.1}%");
                 io::stdout().flush().ok();
             }))
             .await?;
diff --git a/sdk/rust/.cargo/config.toml b/sdk/rust/.cargo/config.toml
diff --git a/sdk/rust/README.md b/sdk/rust/README.md
@@ -191,10 +191,10 @@ Download, load, and unload:
 
 ```rust
 // Download with progress reporting
-model.download(Some(Box::new(|progress: &str| {
-    print!("\r{progress}");
+model.download(Some(|progress: f64| {
+    print!("\r{progress:.1}%");
     std::io::Write::flush(&mut std::io::stdout()).ok();
-}))).await?;
+})).await?;
 
 // Load into memory
 model.load().await?;
diff --git a/sdk/rust/docs/api.md b/sdk/rust/docs/api.md
@@ -151,10 +151,11 @@ pub struct Model { /* private fields */ }
 | `id` | `fn id(&self) -> &str` | Unique identifier of the selected variant. |
 | `variants` | `fn variants(&self) -> &[Arc<ModelVariant>]` | All variants in this model. |
 | `selected_variant` | `fn selected_variant(&self) -> &ModelVariant` | Currently selected variant. |
-| `select_variant` | `fn select_variant(&self, id: &str) -> Result<(), FoundryLocalError>` | Select a variant by id. |
+| `select_variant` | `fn select_variant(&self, variant: &Model) -> Result<(), FoundryLocalError>` | Select a variant from `variants()`. |
+| `select_variant_by_id` | `fn select_variant_by_id(&self, id: &str) -> Result<(), FoundryLocalError>` | Select a variant by its unique id string. |
 | `is_cached` | `async fn is_cached(&self) -> Result<bool, FoundryLocalError>` | Whether the selected variant is cached on disk. |
 | `is_loaded` | `async fn is_loaded(&self) -> Result<bool, FoundryLocalError>` | Whether the selected variant is loaded in memory. |
-| `download` | `async fn download<F>(&self, progress: Option<F>) -> Result<(), FoundryLocalError>` | Download the selected variant. `F: FnMut(&str) + Send + 'static` |
+| `download` | `async fn download<F>(&self, progress: Option<F>) -> Result<(), FoundryLocalError>` | Download the selected variant. `F: FnMut(f64) + Send + 'static` — receives progress as a percentage (0.0–100.0). |
 | `path` | `async fn path(&self) -> Result<PathBuf, FoundryLocalError>` | Local file-system path of the selected variant. |
 | `load` | `async fn load(&self) -> Result<(), FoundryLocalError>` | Load the selected variant into memory. |
 | `unload` | `async fn unload(&self) -> Result<String, FoundryLocalError>` | Unload the selected variant from memory. |
@@ -179,7 +180,7 @@ pub struct ModelVariant { /* private fields */ }
 | `alias` | `fn alias(&self) -> &str` | Alias shared with sibling variants. |
 | `is_cached` | `async fn is_cached(&self) -> Result<bool, FoundryLocalError>` | Whether cached locally. ⚠️ Full IPC per call — prefer `Catalog::get_cached_models()` for batch use. |
 | `is_loaded` | `async fn is_loaded(&self) -> Result<bool, FoundryLocalError>` | Whether currently loaded in memory. |
-| `download` | `async fn download<F>(&self, progress: Option<F>) -> Result<(), FoundryLocalError>` | Download the variant. `F: FnMut(&str) + Send + 'static` |
+| `download` | `async fn download<F>(&self, progress: Option<F>) -> Result<(), FoundryLocalError>` | Download the variant. `F: FnMut(f64) + Send + 'static` — receives progress as a percentage (0.0–100.0). |
 | `path` | `async fn path(&self) -> Result<PathBuf, FoundryLocalError>` | Local file-system path. |
 | `load` | `async fn load(&self) -> Result<(), FoundryLocalError>` | Load into memory. |
 | `unload` | `async fn unload(&self) -> Result<String, FoundryLocalError>` | Unload from memory. |
diff --git a/sdk/rust/examples/chat_completion.rs b/sdk/rust/examples/chat_completion.rs
@@ -40,8 +40,8 @@ async fn main() -> Result<()> {
     if !model.is_cached().await? {
         println!("Downloading model '{}'…", model.alias());
         model
-            .download(Some(|progress: &str| {
-                println!("  {progress}");
+            .download(Some(|progress: f64| {
+                println!("  {progress:.1}%");
             }))
             .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(|p: &str| print!("\r  {p}%"))).await?;
+        model.download(Some(|p: f64| print!("\r  {p:.1}%"))).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(|p: &str| println!("  {p}"))).await?;
+        model.download(Some(|p: f64| println!("  {p:.1}%"))).await?;
     }
     println!("Loading model '{}'…", model.alias());
     model.load().await?;
diff --git a/sdk/rust/src/detail/model.rs b/sdk/rust/src/detail/model.rs
@@ -204,10 +204,10 @@ impl Model {
     }
 
     /// Download the (selected) variant.  If `progress` is provided it
-    /// receives human-readable progress strings as they arrive.
+    /// receives download progress as a percentage (0.0–100.0).
     pub async fn download<F>(&self, progress: Option<F>) -> Result<()>
     where
-        F: FnMut(&str) + Send + 'static,
+        F: FnMut(f64) + Send + 'static,
     {
         self.selected_variant().download(progress).await
     }
@@ -259,15 +259,33 @@ impl Model {
         }
     }
 
-    /// Select a variant by its unique id.
+    /// Select a variant to use for subsequent operations.
+    ///
+    /// The `variant` must be one of the models returned by [`variants`](Model::variants).
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the variant does not belong to this model.
+    /// For single-variant models this always returns an error — use
+    /// [`Catalog::get_model`](crate::Catalog::get_model) to obtain a model
+    /// with all variants available.
+    pub fn select_variant(&self, variant: &Model) -> Result<()> {
+        self.select_variant_by_id(variant.id())
+    }
+
+    /// Select a variant by its unique id string.
+    ///
+    /// This is a convenience method for cases where you have a variant id
+    /// from an external source. Prefer [`select_variant`](Model::select_variant)
+    /// when you already have a [`Model`] reference from [`variants`](Model::variants).
     ///
     /// # Errors
     ///
     /// Returns an error if no variant with the given id exists.
     /// For single-variant models this always returns an error — use
     /// [`Catalog::get_model`](crate::Catalog::get_model) to obtain a model
     /// with all variants available.
-    pub fn select_variant(&self, id: &str) -> Result<()> {
+    pub fn select_variant_by_id(&self, id: &str) -> Result<()> {
         match &self.inner {
             ModelKind::ModelVariant(v) => Err(FoundryLocalError::ModelOperation {
                 reason: format!(
diff --git a/sdk/rust/src/detail/model_variant.rs b/sdk/rust/src/detail/model_variant.rs
@@ -88,13 +88,20 @@ impl ModelVariant {
 
     pub(crate) async fn download<F>(&self, progress: Option<F>) -> Result<()>
     where
-        F: FnMut(&str) + Send + 'static,
+        F: FnMut(f64) + Send + 'static,
     {
         let params = json!({ "Params": { "Model": self.info.id } });
         match progress {
-            Some(cb) => {
+            Some(mut cb) => {
+                let wrapper = move |chunk: &str| {
+                    for token in chunk.split_whitespace() {
+                        if let Ok(pct) = token.parse::<f64>() {
+                            cb(pct);
+                        }
+                    }
+                };
                 self.core
-                    .execute_command_streaming_async("download_model".into(), Some(params), cb)
+                    .execute_command_streaming_async("download_model".into(), Some(params), wrapper)
                     .await?;
             }
             None => {
diff --git a/sdk/rust/tests/integration/model_test.rs b/sdk/rust/tests/integration/model_test.rs
@@ -156,7 +156,7 @@ async fn should_return_non_empty_path_for_cached_model() {
 }
 
 #[tokio::test]
-async fn should_select_variant_by_id() {
+async fn should_select_variant_by_model() {
     let manager = common::get_test_manager();
     let model = manager
         .catalog()
@@ -167,9 +167,10 @@ async fn should_select_variant_by_id() {
     // Remember the original selection so we can restore it afterward.
     let original_id = model.id().to_string();
 
-    let first_variant_id = model.variants()[0].id().to_string();
+    let first_variant = model.variants()[0].clone();
+    let first_variant_id = first_variant.id().to_string();
     model
-        .select_variant(&first_variant_id)
+        .select_variant(&first_variant)
         .expect("select_variant should succeed");
     assert_eq!(
         model.id(),
@@ -180,7 +181,33 @@ async fn should_select_variant_by_id() {
     // Restore the original variant so other tests sharing this
     // model via the catalog are not affected.
     model
-        .select_variant(&original_id)
+        .select_variant_by_id(&original_id)
+        .expect("restoring original variant should succeed");
+}
+
+#[tokio::test]
+async fn should_select_variant_by_id() {
+    let manager = common::get_test_manager();
+    let model = manager
+        .catalog()
+        .get_model(common::TEST_MODEL_ALIAS)
+        .await
+        .expect("get_model failed");
+
+    let original_id = model.id().to_string();
+
+    let first_variant_id = model.variants()[0].id().to_string();
+    model
+        .select_variant_by_id(&first_variant_id)
+        .expect("select_variant_by_id should succeed");
+    assert_eq!(
+        model.id(),
+        first_variant_id,
+        "After select_variant_by_id, id() should match the selected variant"
+    );
+
+    model
+        .select_variant_by_id(&original_id)
         .expect("restoring original variant should succeed");
 }
 
@@ -193,10 +220,10 @@ async fn should_fail_to_select_unknown_variant() {
         .await
         .expect("get_model failed");
 
-    let result = model.select_variant("nonexistent-variant-id");
+    let result = model.select_variant_by_id("nonexistent-variant-id");
     assert!(
         result.is_err(),
-        "select_variant with unknown ID should fail"
+        "select_variant_by_id with unknown ID should fail"
     );
 
     let err_msg = result.unwrap_err().to_string();
