tenho seguinte código tauri v2 rust

use serde::{Deserialize, Serialize};
use std::path::{Path, PathBuf};
use tauri::{AppHandle, Emitter};
use reqwest::Client;
use tokio::fs;
use tokio::io::AsyncWriteExt;
use std::time::{Duration, Instant};

#[derive(Deserialize, Clone)]
struct PatchEntry {
    file_name: String,
}

#[derive(Serialize, Clone)]
struct DownloadInfo {
    current_file: usize,
    total_files: usize,
    file_name: String,
    downloaded_bytes: u64,
    total_bytes: u64,
    speed: f64,
}

#[derive(Serialize, Clone)]
struct DownloadStatus {
    status: String,
    additional_info: Option<String>,
}

fn get_exe_dir() -> PathBuf {
    std::env::current_exe().unwrap().parent().unwrap().to_path_buf()
}

async fn dir_exists(path: &Path) -> Result<bool, std::io::Error> {
    match fs::metadata(path).await {
        Ok(metadata) => Ok(metadata.is_dir()),
        Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(false),
        Err(err) => Err(err),
    }
}

async fn read_patch_file(path: &Path) -> Result<Vec<PatchEntry>, String> {
    let content = fs::read_to_string(path).await.map_err(|e| e.to_string())?;
    let patches: Vec<PatchEntry> = serde_json::from_str(&content).map_err(|e| e.to_string())?;
    Ok(patches)
}

async fn emit_download_status(app_handle: &AppHandle, status: &str, additional_info: Option<String>,) -> Result<(), String> {
    app_handle.emit("download_status", DownloadStatus {status: status.to_string(), additional_info,}).map_err(|e| e.to_string())
}

async fn download_file(
    app_handle: &AppHandle,
    client: &Client,
    entry: &PatchEntry,
    download_dir: &Path,
    current_file: usize,
    total_files: usize,
) -> Result<(), String> {

    let file_path = download_dir.join(&entry.file_name);

    loop {
        let url = format!("https://hil-speed.hetzner.com/{}", entry.file_name);
        let mut response = match client.get(&url).send().await {
            Ok(resp) => {
                if resp.status().is_success() {
                    resp
                } else {
                    return Err(format!("Falha ao baixar '{}': HTTP {}", entry.file_name, resp.status()));
                }
            },
            Err(_) => {
                // Inicie a contagem regressiva e emita eventos
                let mut countdown = 15;
                while countdown > 0 {
                    emit_download_status(app_handle, "Reconnecting", None, Some(countdown)).await?;
                    tokio::time::sleep(Duration::from_secs(1)).await;
                    countdown -= 1;
                }
                continue; // Tente novamente
            }
        };

        let total_bytes = response.content_length().unwrap_or(0);

        // Remova o arquivo existente, se houver
        let _ = fs::remove_file(&file_path).await;

        let mut file = fs::File::create(&file_path).await.map_err(|e| e.to_string())?;

        let mut downloaded_bytes = 0u64;
        let start_time = Instant::now();

        emit_download_status(app_handle, "Start", None, None).await?;

        let mut last_emit_time = Instant::now();
        let mut downloading_message_sent = false;

        let mut download_error = false;

        while let Some(chunk) = match response.chunk().await {
            Ok(chunk_opt) => chunk_opt,
            Err(_) => {
                // Erro de conexão durante o download
                download_error = true;
                break;
            }
        } {
            if let Err(e) = file.write_all(&chunk).await {
                return Err(format!("Erro ao escrever no arquivo '{}': {}", entry.file_name, e.to_string()));
            }
            downloaded_bytes += chunk.len() as u64;

            let now = Instant::now();
            if now.duration_since(last_emit_time) >= Duration::from_millis(200) {
                if !downloading_message_sent {
                    emit_download_status(app_handle, "Downloading", None, None).await?;
                    downloading_message_sent = true;
                }

                let speed = if start_time.elapsed().is_zero() {
                    0.0
                } else {
                    downloaded_bytes as f64 / start_time.elapsed().as_secs_f64()
                };

                app_handle.emit(
                    "download_info",
                    DownloadInfo {
                        current_file,
                        total_files,
                        file_name: entry.file_name.clone(),
                        downloaded_bytes,
                        total_bytes,
                        speed,
                    },
                )
                .map_err(|e| e.to_string())?;
                last_emit_time = now;
            }
        }

        if download_error {
            // Feche o arquivo
            drop(file);

            // Inicie a reconexão
            let mut countdown = 15;
            while countdown > 0 {
                emit_download_status(app_handle, "Reconnecting", None, Some(countdown)).await?;
                tokio::time::sleep(Duration::from_secs(1)).await;
                countdown -= 1;
            }

            // Tente reconectar
            if let Err(_) = check_server_connection(client, "https://hil-speed.hetzner.com/", app_handle).await {
                continue;
            } else {
                continue;
            }
        } else {
            break;
        }
    }

    Ok(())
}

async fn check_server_connection(client: &Client, url: &str) -> Result<(), String> {
    let response = client.get(url).send().await.map_err(|e| e.to_string())?;
    if response.status().is_success() {
        Ok(())
    } else {
        Err(format!("Falha ao conectar ao servidor: HTTP {}", response.status()))
    }
}

#[tauri::command]
pub async fn start_downloads(app_handle: AppHandle) -> Result<(), String> {
    let exe_dir = get_exe_dir();

    let patch_file_path = exe_dir.join("patch.json");
    let download_dir = exe_dir.join("patchs");

    if !dir_exists(&download_dir).await.map_err(|e| e.to_string())? {
        fs::create_dir_all(&download_dir).await.map_err(|e| e.to_string())?;
    }

    let patches = read_patch_file(&patch_file_path).await?;

    let client = Client::new();
    let total_files = patches.len();

    emit_download_status(&app_handle, "Connecting", None).await?;

    let server_url = "https://hil-speed.hetzner.com/";
    if let Err(err) = check_server_connection(&client, server_url).await {
        let error_message = format!("Erro ao conectar ao servidor: {}", err);
        eprintln!("{}", error_message);
        emit_download_status(&app_handle, "Error", Some(error_message.clone())).await?;
        return Err(error_message);
    }

    emit_download_status(&app_handle, "Connected", None).await?;

    for (idx, entry) in patches.iter().enumerate() {
        let current_file = idx + 1;
        if let Err(err) = download_file(&app_handle, &client, entry, &download_dir, current_file, total_files).await {
            let error_message = format!("Erro ao baixar '{}': {}", entry.file_name, err);
            eprintln!("{}", error_message);
            emit_download_status(&app_handle, "Error", Some(error_message.clone())).await?;
            return Err(error_message);
        }
    }

    // Emitir status de conclusão
    emit_download_status(&app_handle, "Completed", None).await?;

    Ok(())
}

recebo erro

error[E0590]: `break` or `continue` with no label in the condition of a `while` loop
   --> src\download.rs:107:17
    |
107 |                 break;
    |                 ^^^^^ unlabeled `break` in the condition of a `while` loop

error[E0061]: this function takes 3 arguments but 4 arguments were supplied
  --> src\download.rs:77:21
   |
77 |                     emit_download_status(app_handle, "Reconnecting", None, Some(countdown)).await?;
   |                     ^^^^^^^^^^^^^^^^^^^^                                 -----------------
   |                                                                          | |
   |                                                                          | unexpected argument of type `std::option::Option<{integer}>`
   |                                                                          help: remove the extra argument
   |
note: function defined here
  --> src\download.rs:48:10
   |
48 | async fn emit_download_status(app_handle: &AppHandle, status: &str, additional_info: Option<String>,) -> Result<(), String> {
   |          ^^^^^^^^^^^^^^^^^^^^ ----------------------  ------------  -------------------------------

error[E0061]: this function takes 3 arguments but 4 arguments were supplied
  --> src\download.rs:95:9
   |
95 |         emit_download_status(app_handle, "Start", None, None).await?;
   |         ^^^^^^^^^^^^^^^^^^^^                          ------
   |                                                       | |
   |                                                       | unexpected argument of type `std::option::Option<_>`
   |                                                       help: remove the extra argument
   |
note: function defined here
  --> src\download.rs:48:10
   |
48 | async fn emit_download_status(app_handle: &AppHandle, status: &str, additional_info: Option<String>,) -> Result<(), String> {
   |          ^^^^^^^^^^^^^^^^^^^^ ----------------------  ------------  -------------------------------

error[E0308]: `match` arms have incompatible types
   --> src\download.rs:107:17
    |
102 |           while let Some(chunk) = match response.chunk().await {
    |  _________________________________-
103 | |             Ok(chunk_opt) => chunk_opt,
    | |                              --------- this is found to be of type `std::option::Option<bytes::bytes::Bytes>`
104 | |             Err(_) => {
105 | |                 // Erro de conexão durante o download
106 | |                 download_error = true;
107 | |                 break;
    | |                 ^^^^^^ expected `Option<Bytes>`, found `()`
108 | |             }
109 | |         } {
    | |_________- `match` arms have incompatible types
    |
    = note:   expected enum `std::option::Option<bytes::bytes::Bytes>`
            found unit type `()`

error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
   --> src\download.rs:102:19
    |
102 |         while let Some(chunk) = match response.chunk().await {
    |                   ^^^^^^^^^^^ doesn't have a size known at compile-time
    |
    = help: the trait `Sized` is not implemented for `[u8]`
note: required by a bound in `std::prelude::v1::Some`
   --> C:\Users\jonatas\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib/rustlib/src/rust\library\core\src\option.rs:574:17
    |
574 | pub enum Option<T> {
    |                 ^ required by this bound in `std::prelude::v1::Some`
...
582 |     Some(#[stable(feature = "rust1", since = "1.0.0")] T),
    |     ---- required by a bound in this tuple variant

error[E0061]: this function takes 3 arguments but 4 arguments were supplied
   --> src\download.rs:118:21
    |
118 |                     emit_download_status(app_handle, "Downloading", None, None).await?;
    |                     ^^^^^^^^^^^^^^^^^^^^                                ------
    |                                                                         | |
    |                                                                         | unexpected argument of type `std::option::Option<_>`
    |                                                                         help: remove the extra argument
    |
note: function defined here
   --> src\download.rs:48:10
    |
48  | async fn emit_download_status(app_handle: &AppHandle, status: &str, additional_info: Option<String>,) -> Result<(), String> {
    |          ^^^^^^^^^^^^^^^^^^^^ ----------------------  ------------  -------------------------------

error[E0061]: this function takes 3 arguments but 4 arguments were supplied
   --> src\download.rs:151:17
    |
151 |                 emit_download_status(app_handle, "Reconnecting", None, Some(countdown)).await?;
    |                 ^^^^^^^^^^^^^^^^^^^^                                 -----------------
    |                                                                      | |
    |                                                                      | unexpected argument of type `std::option::Option<{integer}>`
    |                                                                      help: remove the extra argument
    |
note: function defined here
   --> src\download.rs:48:10
    |
48  | async fn emit_download_status(app_handle: &AppHandle, status: &str, additional_info: Option<String>,) -> Result<(), String> {
    |          ^^^^^^^^^^^^^^^^^^^^ ----------------------  ------------  -------------------------------

error[E0061]: this function takes 2 arguments but 3 arguments were supplied
   --> src\download.rs:157:29
    |
157 |             if let Err(_) = check_server_connection(client, "https://hil-speed.hetzner.com/", app_handle).await {
    |                             ^^^^^^^^^^^^^^^^^^^^^^^                                         ------------
    |                                                                                             | |
    |                                                                                             | unexpected argument of type `&AppHandle`
    |                                                                                             help: remove the extra argument
    |
note: function defined here
   --> src\download.rs:170:10
    |
170 | async fn check_server_connection(client: &Client, url: &str) -> Result<(), String> {
    |          ^^^^^^^^^^^^^^^^^^^^^^^ ---------------  ---------

Some errors have detailed explanations: E0061, E0277, E0308, E0590.
For more information about an error, try `rustc --explain E0061`.