Fix Rust tutorial samples to match updated SDK API

- Use ::from() instead of ::new() for message construction
- Use |progress: &str| instead of |progress: f32| for download callbacks
- Use serde_json::from_value for assistant message construction
- Use ChatCompletionMessageToolCalls::Function enum pattern for tool calls
- Use foundry_local_sdk::openai::ChatClient for type annotations
- Add is_cached() check before download
- Add serde_json dependency to tutorial-chat-assistant

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: samuel100

samples/rust/tutorial-chat-assistant/Cargo.toml

@@ -8,3 +8,4 @@ foundry-local-sdk = { path = "../../../sdk/rust" }
 tokio = { version = "1", features = ["full"] }
 tokio-stream = "0.1"
 anyhow = "1"
+serde_json = "1"

samples/rust/tutorial-chat-assistant/src/main.rs

@@ -1,11 +1,11 @@
 // <complete_code>
 // <imports>
 use foundry_local_sdk::{
-    ChatCompletionRequestAssistantMessage, ChatCompletionRequestMessage,
+    ChatCompletionRequestMessage,
     ChatCompletionRequestSystemMessage, ChatCompletionRequestUserMessage,
     FoundryLocalConfig, FoundryLocalManager,
 };
-use std::io::{BufRead, Write};
+use std::io::{self, BufRead, Write};
 use tokio_stream::StreamExt;
 // </imports>
 
@@ -18,13 +18,16 @@ async fn main() -> anyhow::Result<()> {
     // Select and load a model from the catalog
     let model = manager.catalog().get_model("phi-3.5-mini").await?;
 
-    model
-        .download(Some(|progress: f32| {
-            print!("\rDownloading model: {:.2}%", progress);
-            std::io::stdout().flush().unwrap();
-        }))
-        .await?;
-    println!();
+    if !model.is_cached().await? {
+        println!("Downloading model...");
+        model
+            .download(Some(|progress: &str| {
+                print!("\r  {progress}");
+                io::stdout().flush().ok();
+            }))
+            .await?;
+        println!();
+    }
 
     model.load().await?;
     println!("Model loaded and ready.");
@@ -36,7 +39,7 @@ async fn main() -> anyhow::Result<()> {
     // <system_prompt>
     // Start the conversation with a system prompt
     let mut messages: Vec<ChatCompletionRequestMessage> = vec![
-        ChatCompletionRequestSystemMessage::new(
+        ChatCompletionRequestSystemMessage::from(
             "You are a helpful, friendly assistant. Keep your responses \
              concise and conversational. If you don't know something, say so.",
         )
@@ -46,11 +49,11 @@ async fn main() -> anyhow::Result<()> {
 
     println!("\nChat assistant ready! Type 'quit' to exit.\n");
 
-    let stdin = std::io::stdin();
+    let stdin = io::stdin();
     // <conversation_loop>
     loop {
         print!("You: ");
-        std::io::stdout().flush()?;
+        io::stdout().flush()?;
 
         let mut input = String::new();
         stdin.lock().read_line(&mut input)?;
@@ -61,27 +64,32 @@ async fn main() -> anyhow::Result<()> {
         }
 
         // Add the user's message to conversation history
-        messages.push(ChatCompletionRequestUserMessage::new(input).into());
+        messages.push(ChatCompletionRequestUserMessage::from(input).into());
 
         // <streaming>
         // Stream the response token by token
         print!("Assistant: ");
-        std::io::stdout().flush()?;
+        io::stdout().flush()?;
         let mut full_response = String::new();
         let mut stream = client.complete_streaming_chat(&messages, None).await?;
         while let Some(chunk) = stream.next().await {
             let chunk = chunk?;
-            if let Some(content) = &chunk.choices[0].message.content {
-                print!("{}", content);
-                std::io::stdout().flush()?;
-                full_response.push_str(content);
+            if let Some(choice) = chunk.choices.first() {
+                if let Some(ref content) = choice.delta.content {
+                    print!("{content}");
+                    io::stdout().flush()?;
+                    full_response.push_str(content);
+                }
             }
         }
         println!("\n");
         // </streaming>
 
         // Add the complete response to conversation history
-        messages.push(ChatCompletionRequestAssistantMessage::new(full_response).into());
+        let assistant_msg: ChatCompletionRequestMessage = serde_json::from_value(
+            serde_json::json!({"role": "assistant", "content": full_response}),
+        )?;
+        messages.push(assistant_msg);
     }
     // </conversation_loop>
 

samples/rust/tutorial-document-summarizer/src/main.rs

@@ -1,26 +1,31 @@
 // <complete_code>
 // <imports>
 use foundry_local_sdk::{
-    ChatCompletionRequestMessage, ChatCompletionRequestSystemMessage,
-    ChatCompletionRequestUserMessage, FoundryLocalConfig, FoundryLocalManager,
+    ChatCompletionRequestMessage,
+    ChatCompletionRequestSystemMessage,
+    ChatCompletionRequestUserMessage, FoundryLocalConfig,
+    FoundryLocalManager,
 };
-use std::io::Write;
+use std::io::{self, Write};
 use std::path::Path;
 use std::{env, fs};
 // </imports>
 
 async fn summarize_file(
-    client: &foundry_local_sdk::ChatClient,
+    client: &foundry_local_sdk::openai::ChatClient,
     file_path: &Path,
     system_prompt: &str,
 ) -> anyhow::Result<()> {
     let content = fs::read_to_string(file_path)?;
     let messages: Vec<ChatCompletionRequestMessage> = vec![
-        ChatCompletionRequestSystemMessage::new(system_prompt).into(),
-        ChatCompletionRequestUserMessage::new(&content).into(),
+        ChatCompletionRequestSystemMessage::from(system_prompt)
+            .into(),
+        ChatCompletionRequestUserMessage::from(content.as_str())
+            .into(),
     ];
 
-    let response = client.complete_chat(&messages, None).await?;
+    let response =
+        client.complete_chat(&messages, None).await?;
     let summary = response.choices[0]
         .message
         .content
@@ -31,14 +36,16 @@ async fn summarize_file(
 }
 
 async fn summarize_directory(
-    client: &foundry_local_sdk::ChatClient,
+    client: &foundry_local_sdk::openai::ChatClient,
     directory: &Path,
     system_prompt: &str,
 ) -> anyhow::Result<()> {
     let mut txt_files: Vec<_> = fs::read_dir(directory)?
         .filter_map(|entry| entry.ok())
         .filter(|entry| {
-            entry.path().extension()
+            entry
+                .path()
+                .extension()
                 .map(|ext| ext == "txt")
                 .unwrap_or(false)
         })
@@ -47,14 +54,25 @@ async fn summarize_directory(
     txt_files.sort_by_key(|e| e.path());
 
     if txt_files.is_empty() {
-        println!("No .txt files found in {}", directory.display());
+        println!(
+            "No .txt files found in {}",
+            directory.display()
+        );
         return Ok(());
     }
 
     for entry in &txt_files {
         let file_name = entry.file_name();
-        println!("--- {} ---", file_name.to_string_lossy());
-        summarize_file(client, &entry.path(), system_prompt).await?;
+        println!(
+            "--- {} ---",
+            file_name.to_string_lossy()
+        );
+        summarize_file(
+            client,
+            &entry.path(),
+            system_prompt,
+        )
+        .await?;
         println!();
     }
 
@@ -70,15 +88,21 @@ async fn main() -> anyhow::Result<()> {
     )?;
 
     // Select and load a model from the catalog
-    let model = manager.catalog().get_model("phi-3.5-mini").await?;
-
-    model
-        .download(Some(|progress: f32| {
-            print!("\rDownloading model: {:.2}%", progress);
-            std::io::stdout().flush().unwrap();
-        }))
+    let model = manager
+        .catalog()
+        .get_model("phi-3.5-mini")
         .await?;
-    println!();
+
+    if !model.is_cached().await? {
+        println!("Downloading model...");
+        model
+            .download(Some(|progress: &str| {
+                print!("\r  {progress}");
+                io::stdout().flush().ok();
+            }))
+            .await?;
+        println!();
+    }
 
     model.load().await?;
     println!("Model loaded and ready.\n");
@@ -91,25 +115,36 @@ async fn main() -> anyhow::Result<()> {
     // </init>
 
     // <summarization>
-    let system_prompt =
-        "Summarize the following document into concise bullet points. \
-         Focus on the key points and main ideas.";
+    let system_prompt = "Summarize the following document \
+         into concise bullet points. Focus on the key \
+         points and main ideas.";
 
     // <file_reading>
-    let target = env::args().nth(1)
+    let target = env::args()
+        .nth(1)
         .unwrap_or_else(|| "document.txt".to_string());
     let target_path = Path::new(&target);
     // </file_reading>
 
     if target_path.is_dir() {
-        summarize_directory(&client, target_path, system_prompt).await?;
+        summarize_directory(
+            &client,
+            target_path,
+            system_prompt,
+        )
+        .await?;
     } else {
         let file_name = target_path
             .file_name()
             .map(|n| n.to_string_lossy().to_string())
             .unwrap_or_else(|| target.clone());
         println!("--- {} ---", file_name);
-        summarize_file(&client, target_path, system_prompt).await?;
+        summarize_file(
+            &client,
+            target_path,
+            system_prompt,
+        )
+        .await?;
     }
     // </summarization>