From 6520e49066b70698bec4df966e1ab5f7c5a83a19 Mon Sep 17 00:00:00 2001
From: kura <kura@sina.com>
Date: Wed, 6 May 2026 17:46:06 +0800
Subject: [PATCH] =?UTF-8?q?=E5=A4=84=E7=90=86api=E5=A4=B1=E8=B4=A5?=
 =?UTF-8?q?=E9=A2=91=E7=B9=81channel=20closed?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src-tauri/src/task.rs | 79 ++++++++++++++++++++++++++++++-------------
 1 file changed, 56 insertions(+), 23 deletions(-)

diff --git a/src-tauri/src/task.rs b/src-tauri/src/task.rs
index c29eee5..d6a83a9 100644
--- a/src-tauri/src/task.rs
+++ b/src-tauri/src/task.rs
@@ -455,6 +455,7 @@ async fn incremental_translate(
     let mut buffer: Vec<SubtitleSegment> = Vec::new();
     let mut translated_count: usize = 0;
     let idle_flush_after = Duration::from_secs(3);
+    let mut translate_error: Option<String> = None;
 
     let emit_translate_progress =
         |window: &Window, task_id: &str, done: usize, total: usize| -> Result<()> {
@@ -500,7 +501,10 @@ async fn incremental_translate(
                 buffer.push(segment);
 
                 if buffer.len() >= batch_size {
-                    translate_buffered_segments(
+                    if let Some(ref error) = translate_error {
+                        emit_log(window, task_id, format!("translation: skip batch due to previous error: {error}"))?;
+                        buffer.clear();
+                    } else if let Err(e) = translate_buffered_segments(
                         &translator,
                         window,
                         app_state,
@@ -512,37 +516,53 @@ async fn incremental_translate(
                         context_size,
                         "batch",
                     )
-                    .await?;
-                    emit_translate_progress(window, task_id, translated_count, all_segments.len())?;
+                    .await
+                    {
+                        eprintln!("translation error: {e:#}");
+                        translate_error = Some(e.to_string());
+                        let _ = emit_log(window, task_id, format!("translation: batch failed: {e}"));
+                    } else {
+                        let _ = emit_translate_progress(window, task_id, translated_count, all_segments.len());
+                    }
                 }
             }
             Ok(None) => break,
             Err(_) => {
-                if buffer.is_empty() {
-                    continue;
+                if !buffer.is_empty() {
+                    if let Some(ref error) = translate_error {
+                        emit_log(window, task_id, format!("translation: skip idle batch due to previous error: {error}"))?;
+                        buffer.clear();
+                    } else if let Err(e) = translate_buffered_segments(
+                        &translator,
+                        window,
+                        app_state,
+                        task_id,
+                        target_lang,
+                        &all_segments,
+                        &mut buffer,
+                        &mut translated_count,
+                        context_size,
+                        "idle batch",
+                    )
+                    .await
+                    {
+                        eprintln!("translation error: {e:#}");
+                        translate_error = Some(e.to_string());
+                        let _ = emit_log(window, task_id, format!("translation: idle batch failed: {e}"));
+                    } else {
+                        let _ = emit_translate_progress(window, task_id, translated_count, all_segments.len());
+                    }
                 }
-
-                translate_buffered_segments(
-                    &translator,
-                    window,
-                    app_state,
-                    task_id,
-                    target_lang,
-                    &all_segments,
-                    &mut buffer,
-                    &mut translated_count,
-                    context_size,
-                    "idle batch",
-                )
-                .await?;
-                emit_translate_progress(window, task_id, translated_count, all_segments.len())?;
             }
         }
     }
 
     // Flush remaining segments below batch_size
     if !buffer.is_empty() {
-        translate_buffered_segments(
+        if let Some(ref error) = translate_error {
+            let _ = emit_log(window, task_id, format!("translation: skip final batch due to previous error: {error}"));
+            buffer.clear();
+        } else if let Err(e) = translate_buffered_segments(
             &translator,
             window,
             app_state,
@@ -554,8 +574,21 @@ async fn incremental_translate(
             context_size,
             "final batch",
         )
-        .await?;
-        emit_translate_progress(window, task_id, translated_count, all_segments.len())?;
+        .await
+        {
+            eprintln!("translation error: {e:#}");
+            translate_error = Some(e.to_string());
+            let _ = emit_log(window, task_id, format!("translation: final batch failed: {e}"));
+        } else {
+            let _ = emit_translate_progress(window, task_id, translated_count, all_segments.len());
+        }
+    }
+
+    if let Some(ref error) = translate_error {
+        emit_log(window, task_id, format!("translation: completed with error: {error}"))?;
+        // Return Ok to keep the channel receiver alive until all
+        // whisper segment callback send tasks have completed
+        return Ok(());
     }
 
     // Translation complete