Upgrade DeepSeek client and improve API reliability

app.py

@@ -94,15 +94,19 @@ def clean_trailing_references(text, keywords=("reference", "references", "refere
 def clean_markdown_headings(text):
     return re.sub(r'(?m)^#+\s+(.*)$', r'**\1**', text)
 
-global_ds_key = os.environ.get("DEEPSEEK_API_KEY", "")
-if not global_ds_key:
-    try: global_ds_key = st.secrets.get("DEEPSEEK_API_KEY", "")
-    except: pass
+def _read_runtime_secret(name):
+    # Read a Hugging Face/Streamlit secret and remove copied whitespace.
+    value = os.environ.get(name, "")
+    if not value:
+        try:
+            value = st.secrets.get(name, "")
+        except Exception:
+            value = ""
+    return str(value or "").strip()
 
-global_s2_key = os.environ.get("S2_API_KEY", "")
-if not global_s2_key:
-    try: global_s2_key = st.secrets.get("S2_API_KEY", "")
-    except: pass
+
+global_ds_key = _read_runtime_secret("DEEPSEEK_API_KEY")
+global_s2_key = _read_runtime_secret("S2_API_KEY")
 
 WECHAT_BLOCKER_JS = """<script>try{var ua=navigator.userAgent.toLowerCase();if(ua.indexOf('micromessenger')!==-1){var parentDoc=window.parent.document;if(!parentDoc.getElementById('wx-blocker')){var overlay=parentDoc.createElement('div');overlay.id='wx-blocker';overlay.style.cssText='position:fixed;top:0;left:0;width:100vw;height:100vh;background:#1a365d;z-index:9999999;color:white;display:flex;flex-direction:column;align-items:center;justify-content:center;text-align:center;font-family:sans-serif;padding:30px;box-sizing:border-box;';overlay.innerHTML='<h2 style="font-size:26px;margin-bottom:15px;font-weight:bold;">环境受限 / Restricted</h2><p style="font-size:18px;line-height:1.6;color:#e2e8f0;max-width:100%;">为了保障最终双语 ZIP 压缩包正常下载，<b>本系统禁止在微信内直接运行</b>。<br><br>👉 <b>请点击右上角 [···] 菜单，选择“在浏览器打开” (Open in Browser)</b></p>';parentDoc.body.appendChild(overlay);}}}catch(e){}</script>"""
 components.html(WECHAT_BLOCKER_JS, height=0, width=0)
@@ -788,11 +792,11 @@ if st.session_state.start_pipeline or st.session_state.resume_pipeline:
                     update_heartbeat()
                     st.write(f"📡 已发起 DeepSeek API 请求...")
                     
-                    target_model = "deepseek-chat"
+                    target_model = "deepseek-v4-flash"
                     st.write(f"✍️ 核心推导由 R1 完成，当前节点使用 {target_model} 高速执笔...")
                     
                     en_draft_clean = re.sub(r'<think>.*?</think>', '', en_ph.write_stream(
-                        stream_with_heartbeat(agent.stream_deepseek(sys_prompt_m3, base_user, max_tokens=6000, model_name=target_model))
+                        stream_with_heartbeat(agent.stream_deepseek(sys_prompt_m3, base_user, max_tokens=6000, model_name=target_model, thinking=False))
                     ), flags=re.DOTALL).strip()
                     
                     status.update(label=f"✅ 【{display_name}】撰写完毕！", state="complete", expanded=False)

config.py

@@ -22,7 +22,33 @@ def load_config():
         },
         
         # --- API 节点配置 ---
-        "deepseek_api_url": os.environ.get("DEEPSEEK_API_URL", "https://api.deepseek.com/chat/completions"),
+        "deepseek_api_url": os.environ.get(
+        "DEEPSEEK_API_URL",
+        "https://api.deepseek.com/chat/completions",
+    ),
+    "deepseek_default_model": os.environ.get(
+        "DEEPSEEK_DEFAULT_MODEL",
+        "deepseek-v4-flash",
+    ),
+    "deepseek_fallback_model": os.environ.get(
+        "DEEPSEEK_FALLBACK_MODEL",
+        "deepseek-v4-flash",
+    ),
+    "deepseek_default_thinking": os.environ.get(
+        "DEEPSEEK_DEFAULT_THINKING",
+        "true",
+    ).strip().lower() in {"1", "true", "yes", "on"},
+    "deepseek_reasoning_effort": os.environ.get(
+        "DEEPSEEK_REASONING_EFFORT",
+        "high",
+    ),
+    "deepseek_max_retries": int(
+        os.environ.get("DEEPSEEK_MAX_RETRIES", "3")
+    ),
+    "deepseek_show_reasoning": os.environ.get(
+        "DEEPSEEK_SHOW_REASONING",
+        "false",
+    ).strip().lower() in {"1", "true", "yes", "on"},
         "openalex_api_url": os.environ.get("OPENALEX_API_URL", "https://api.openalex.org/works"),
         "s2_api_url": os.environ.get("S2_API_URL", "https://api.semanticscholar.org/graph/v1"),
         

core/pipeline_agent.py

@@ -25,9 +25,31 @@ except ImportError:
 
 from config import APP_CONFIG
 
+
+class DeepSeekAPIError(RuntimeError):
+    pass
+
+
+class DeepSeekAuthenticationError(DeepSeekAPIError):
+    pass
+
+
+class DeepSeekBalanceError(DeepSeekAPIError):
+    pass
+
+
+class DeepSeekRequestError(DeepSeekAPIError):
+    pass
+
+
 class SSciPipelineAgent:
     def __init__(self, ds_key, s2_key=""):
-        self.ds_key = ds_key
+        self.ds_key = str(ds_key or "").strip()
+        if not self.ds_key:
+            raise DeepSeekAuthenticationError(
+                "DEEPSEEK_API_KEY is empty. Configure it in Hugging Face "
+                "Space Settings > Variables and secrets."
+            )
         try: 
             self.s2_key = st.secrets.get("S2_API_KEY", s2_key)
         except: 
@@ -55,6 +77,24 @@ class SSciPipelineAgent:
         self.chunk_words_cyrillic = APP_CONFIG["chunk_words_cyrillic"]
         
         self.deepseek_api_url = APP_CONFIG["deepseek_api_url"]
+        self.deepseek_default_model = str(
+            APP_CONFIG.get("deepseek_default_model", "deepseek-v4-flash")
+        ).strip()
+        self.deepseek_fallback_model = str(
+            APP_CONFIG.get("deepseek_fallback_model", "deepseek-v4-flash")
+        ).strip()
+        self.deepseek_default_thinking = bool(
+            APP_CONFIG.get("deepseek_default_thinking", True)
+        )
+        self.deepseek_reasoning_effort = str(
+            APP_CONFIG.get("deepseek_reasoning_effort", "high")
+        ).strip().lower()
+        self.deepseek_max_retries = max(
+            1, int(APP_CONFIG.get("deepseek_max_retries", 3))
+        )
+        self.deepseek_show_reasoning = bool(
+            APP_CONFIG.get("deepseek_show_reasoning", False)
+        )
         self.openalex_api_url = APP_CONFIG["openalex_api_url"]
         self.s2_api_url = APP_CONFIG["s2_api_url"]
         self.timeouts = APP_CONFIG["api_timeouts"]
@@ -255,138 +295,472 @@ class SSciPipelineAgent:
             return self._truncate_context(full, max_tokens)
         return full
 
-    def call_deepseek(self, system_prompt, user_prompt, max_tokens=8000, temp=0.3, model_name="deepseek-reasoner"):
-        tokens_est = self._count_tokens(user_prompt)
-        logging.info(f"🚀 [DeepSeek 静态请求] 模型: {model_name} | MaxTokens: {max_tokens} | 输入估算: {tokens_est} tokens")
-        
-        for attempt in range(3):
-            with self.lock: 
+    def _resolve_deepseek_model(self, model_name=None, thinking=None):
+        # Legacy names are accepted only as internal aliases.
+        requested = str(
+            model_name or self.deepseek_default_model
+        ).strip().lower()
+
+        legacy_aliases = {
+            "deepseek-chat": ("deepseek-v4-flash", False),
+            "deepseek-reasoner": ("deepseek-v4-flash", True),
+        }
+        if requested in legacy_aliases:
+            public_model, alias_thinking = legacy_aliases[requested]
+            if thinking is None:
+                thinking = alias_thinking
+            return public_model, bool(thinking)
+
+        allowed_models = {"deepseek-v4-flash", "deepseek-v4-pro"}
+        if requested not in allowed_models:
+            raise DeepSeekRequestError(
+                f"Unsupported DeepSeek model: {requested!r}. "
+                "Use 'deepseek-v4-flash' or 'deepseek-v4-pro'."
+            )
+
+        if thinking is None:
+            thinking = self.deepseek_default_thinking
+
+        return requested, bool(thinking)
+
+    def _build_deepseek_payload(
+        self,
+        system_prompt,
+        user_prompt,
+        *,
+        model_name,
+        thinking,
+        max_tokens,
+        temp,
+        stream,
+        reasoning_effort,
+    ):
+        effort = str(
+            reasoning_effort or self.deepseek_reasoning_effort
+        ).strip().lower()
+        if effort not in {"high", "max"}:
+            effort = "high"
+
+        payload = {
+            "model": model_name,
+            "messages": [
+                {"role": "system", "content": str(system_prompt)},
+                {"role": "user", "content": str(user_prompt)},
+            ],
+            "max_tokens": int(max_tokens),
+            "stream": bool(stream),
+            "thinking": {
+                "type": "enabled" if thinking else "disabled"
+            },
+        }
+
+        if thinking:
+            payload["reasoning_effort"] = effort
+        else:
+            payload["temperature"] = max(
+                0.0, min(float(temp), 2.0)
+            )
+
+        return payload
+
+    @staticmethod
+    def _deepseek_headers(api_key):
+        return {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "SmartPaper/DeepSeekV4",
+        }
+
+    @staticmethod
+    def _safe_response_text(response, limit=600):
+        try:
+            return response.text[:limit]
+        except Exception:
+            return ""
+
+    def _raise_for_deepseek_status(self, response):
+        status = int(response.status_code)
+        detail = self._safe_response_text(response)
+
+        if status == 401:
+            raise DeepSeekAuthenticationError(
+                "DeepSeek authentication failed (401). "
+                "Check DEEPSEEK_API_KEY in Hugging Face Space Secrets."
+            )
+        if status == 402:
+            raise DeepSeekBalanceError(
+                "DeepSeek account balance is insufficient (402)."
+            )
+        if status == 400:
+            raise DeepSeekRequestError(
+                f"DeepSeek rejected the request format (400): {detail}"
+            )
+        if status == 404:
+            raise DeepSeekRequestError(
+                f"DeepSeek model or endpoint was not found (404): {detail}"
+            )
+        if status == 422:
+            raise DeepSeekRequestError(
+                f"DeepSeek request parameters are invalid (422): {detail}"
+            )
+
+        if status in {408, 409, 425, 429, 500, 502, 503, 504}:
+            raise requests.exceptions.HTTPError(
+                f"Transient DeepSeek API failure ({status}): {detail}",
+                response=response,
+            )
+
+        raise DeepSeekRequestError(
+            f"Unexpected DeepSeek API status {status}: {detail}"
+        )
+
+    @staticmethod
+    def _retry_delay(attempt_index):
+        base = min(2 ** attempt_index, 8)
+        return base + random.uniform(0.25, 1.25)
+
+    @staticmethod
+    def _parse_sse_line(raw_line):
+        if raw_line is None:
+            return None
+        if isinstance(raw_line, bytes):
+            line = raw_line.decode("utf-8", errors="replace").strip()
+        else:
+            line = str(raw_line).strip()
+
+        if not line or not line.startswith("data:"):
+            return None
+
+        data = line[5:].strip()
+        if not data:
+            return None
+        if data == "[DONE]":
+            return {"done": True}
+
+        try:
+            return json.loads(data)
+        except json.JSONDecodeError:
+            logging.warning(
+                "⚠️ Ignored malformed DeepSeek SSE chunk: %s",
+                data[:160],
+            )
+            return None
+
+    def _attempt_plan(self, requested_model, requested_thinking):
+        total = self.deepseek_max_retries
+        for attempt in range(total):
+            model = requested_model
+            thinking = requested_thinking
+
+            if attempt == total - 1:
+                if model != self.deepseek_fallback_model:
+                    model = self.deepseek_fallback_model
+                if thinking:
+                    thinking = False
+
+            yield attempt, model, thinking
+
+    def call_deepseek(
+        self,
+        system_prompt,
+        user_prompt,
+        max_tokens=8000,
+        temp=0.3,
+        model_name="deepseek-reasoner",
+        thinking=None,
+        reasoning_effort=None,
+    ):
+        requested_model, requested_thinking = (
+            self._resolve_deepseek_model(model_name, thinking)
+        )
+        tokens_est = self._count_tokens(str(user_prompt))
+
+        logging.info(
+            "🚀 [DeepSeek 静态请求] 模型=%s | Thinking=%s | "
+            "MaxTokens=%s | 输入估算=%s tokens",
+            requested_model,
+            requested_thinking,
+            max_tokens,
+            tokens_est,
+        )
+
+        last_error = None
+
+        for attempt, current_model, current_thinking in self._attempt_plan(
+            requested_model, requested_thinking
+        ):
+            with self.lock:
                 self.ds_calls += 1
-            current_model = model_name
-            if attempt == 2 and model_name == "deepseek-reasoner":
-                current_model = "deepseek-chat"
-                temp = 0.3 
-                logging.warning("⚠️ 强制降级为 deepseek-chat 执行本节点！")
-                
-            payload = {
-                "model": current_model, 
-                "messages": [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}], 
-                "max_tokens": max_tokens, 
-                "stream": True 
-            }
-            if current_model != "deepseek-reasoner": 
-                payload["temperature"] = temp
-                
-            full_content = ""
+
+            if (
+                current_model != requested_model
+                or current_thinking != requested_thinking
+            ):
+                logging.warning(
+                    "⚠️ 最后一次尝试降级：模型=%s | Thinking=%s",
+                    current_model,
+                    current_thinking,
+                )
+
+            payload = self._build_deepseek_payload(
+                system_prompt,
+                user_prompt,
+                model_name=current_model,
+                thinking=current_thinking,
+                max_tokens=max_tokens,
+                temp=temp,
+                stream=False,
+                reasoning_effort=reasoning_effort,
+            )
             start_time = time.time()
+
             try:
-                with requests.post(self.deepseek_api_url, headers={"Authorization": f"Bearer {self.ds_key}"}, json=payload, stream=True, timeout=self.timeouts["standard"]) as response:
-                    if response.status_code != 200:
-                        logging.error(f"❌ 尝试 {attempt+1}/3 失败: 状态码 {response.status_code} - {response.text[:200]}")
-                        if attempt == 2: 
-                            raise requests.exceptions.HTTPError("API 熔断")
-                        time.sleep(3 ** attempt)
-                        continue
-                        
-                    for line in response.iter_lines():
-                        if line and line.decode('utf-8').startswith('data: ') and line.decode('utf-8') != 'data: [DONE]':
-                            try:
-                                delta = json.loads(line.decode('utf-8')[6:])['choices'][0].get('delta', {})
-                                content = delta.get('content', '')
-                                if content: 
-                                    full_content += content
-                            except Exception: 
-                                pass
-                
+                response = requests.post(
+                    self.deepseek_api_url,
+                    headers=self._deepseek_headers(self.ds_key),
+                    json=payload,
+                    timeout=self.timeouts["standard"],
+                )
+
+                if response.status_code != 200:
+                    self._raise_for_deepseek_status(response)
+
+                try:
+                    result = response.json()
+                except ValueError as exc:
+                    raise DeepSeekAPIError(
+                        "DeepSeek returned a non-JSON success response."
+                    ) from exc
+
+                choices = result.get("choices") or []
+                if not choices:
+                    raise DeepSeekAPIError(
+                        "DeepSeek returned no choices."
+                    )
+
+                message = choices[0].get("message") or {}
+                content = str(message.get("content") or "").strip()
+
+                if not content:
+                    finish_reason = choices[0].get("finish_reason")
+                    raise DeepSeekAPIError(
+                        "DeepSeek returned empty final content. "
+                        f"finish_reason={finish_reason!r}"
+                    )
+
                 elapsed = time.time() - start_time
-                logging.info(f"✅ [静态请求返回] 耗时: {elapsed:.2f}s | 输出长度: {len(full_content)} 字符")
-                return full_content.strip()
-            except Exception as e:
-                logging.error(f"❌ [网络异常] 尝试 {attempt+1}: {e}")
-                if attempt == 2: 
-                    raise e
-                time.sleep(3 ** attempt)
-
-    def stream_deepseek(self, system_prompt, user_prompt, max_tokens=8000, model_name="deepseek-reasoner"):
-        tokens_est = self._count_tokens(user_prompt)
-        logging.info(f"🌊 [DeepSeek 流式请求] 模型: {model_name} | 输入估算: {tokens_est} tokens")
-        
-        temp = 0.3 if model_name == "deepseek-chat" else 0.2
-        for attempt in range(3):
-            with self.lock: 
+                logging.info(
+                    "✅ [静态请求返回] 耗时=%.2fs | 输出长度=%s 字符",
+                    elapsed,
+                    len(content),
+                )
+                return content
+
+            except (
+                DeepSeekAuthenticationError,
+                DeepSeekBalanceError,
+                DeepSeekRequestError,
+            ):
+                raise
+            except (
+                requests.exceptions.Timeout,
+                requests.exceptions.ConnectionError,
+                requests.exceptions.HTTPError,
+                DeepSeekAPIError,
+            ) as exc:
+                last_error = exc
+                is_last = attempt == self.deepseek_max_retries - 1
+                logging.error(
+                    "❌ DeepSeek 尝试 %s/%s 失败: %s",
+                    attempt + 1,
+                    self.deepseek_max_retries,
+                    exc,
+                )
+                if is_last:
+                    break
+                time.sleep(self._retry_delay(attempt))
+
+        raise DeepSeekAPIError(
+            f"DeepSeek API failed after "
+            f"{self.deepseek_max_retries} attempts: {last_error}"
+        )
+
+    def stream_deepseek(
+        self,
+        system_prompt,
+        user_prompt,
+        max_tokens=8000,
+        model_name="deepseek-reasoner",
+        thinking=None,
+        reasoning_effort=None,
+        temp=0.3,
+    ):
+        requested_model, requested_thinking = (
+            self._resolve_deepseek_model(model_name, thinking)
+        )
+        tokens_est = self._count_tokens(str(user_prompt))
+
+        logging.info(
+            "🚀 [DeepSeek 流式请求] 模型=%s | Thinking=%s | "
+            "MaxTokens=%s | 输入估算=%s tokens",
+            requested_model,
+            requested_thinking,
+            max_tokens,
+            tokens_est,
+        )
+
+        last_error = None
+
+        for attempt, current_model, current_thinking in self._attempt_plan(
+            requested_model, requested_thinking
+        ):
+            with self.lock:
                 self.ds_calls += 1
-            current_model = model_name
-            if attempt >= 1 and model_name == "deepseek-reasoner":
-                current_model = "deepseek-chat"
-                temp = 0.3  
-                logging.warning("⚠️ 推理节点异常，强制降级至 deepseek-chat 并重试。")
-
-            payload = {
-                "model": current_model, 
-                "messages": [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}], 
-                "max_tokens": max_tokens, 
-                "stream": True
-            }
-            if current_model != "deepseek-reasoner": 
-                payload["temperature"] = temp
-                
-            think_heartbeat = 0
-            has_started_reasoning = False
+
+            if (
+                current_model != requested_model
+                or current_thinking != requested_thinking
+            ):
+                logging.warning(
+                    "⚠️ 最后一次尝试降级：模型=%s | Thinking=%s",
+                    current_model,
+                    current_thinking,
+                )
+
+            payload = self._build_deepseek_payload(
+                system_prompt,
+                user_prompt,
+                model_name=current_model,
+                thinking=current_thinking,
+                max_tokens=max_tokens,
+                temp=temp,
+                stream=True,
+                reasoning_effort=reasoning_effort,
+            )
+
+            emitted_content = False
+            reasoning_open = False
+            reasoning_chunks = 0
             start_time = time.time()
-            
+
             try:
-                with requests.post(self.deepseek_api_url, headers={"Authorization": f"Bearer {self.ds_key}"}, json=payload, stream=True, timeout=self.timeouts["stream"]) as response:
+                with requests.post(
+                    self.deepseek_api_url,
+                    headers=self._deepseek_headers(self.ds_key),
+                    json=payload,
+                    stream=True,
+                    timeout=self.timeouts["stream"],
+                ) as response:
                     if response.status_code != 200:
-                        logging.error(f"❌ 流式尝试 {attempt+1}/3 失败: 状态码 {response.status_code}")
-                        if attempt == 2: 
-                            response.raise_for_status()
-                        time.sleep(2)
-                        continue 
-
-                    for line in response.iter_lines():
-                        if line and line.decode('utf-8').startswith('data: ') and line.decode('utf-8') != 'data: [DONE]':
-                            try:
-                                delta = json.loads(line.decode('utf-8')[6:])['choices'][0].get('delta', {})
-                                
-                                reasoning_content = delta.get('reasoning_content', '')
-                                content = delta.get('content', '')
-                                
-                                if reasoning_content:
-                                    if not has_started_reasoning:
-                                        yield "\n<think>\n"
-                                        has_started_reasoning = True
-                                        logging.info(f"🤔 [R1 推理启动] 开始深度思考...")
-                                        
-                                    think_heartbeat += 1
-                                    
-                                    if think_heartbeat % 25 == 0:
-                                        elapsed = time.time() - start_time
-                                        logging.info(f"⏳ [DeepSeek 心跳] {current_model} 思考中... ({elapsed:.1f}秒, 接收 {think_heartbeat} 块)")
-                                    
-                                    yield reasoning_content
-                                    continue
-                                
-                                if has_started_reasoning and not reasoning_content and content:
-                                    yield "\n</think>\n\n"
-                                    has_started_reasoning = False
-                                    elapsed = time.time() - start_time
-                                    logging.info(f"💡 [R1 推理结束] 耗时 {elapsed:.1f}秒。开始流式输出正文...")
-
-                                if content: 
-                                    yield content
-                                    
-                            except Exception: 
-                                pass
-                
-                logging.info(f"🏁 [流式生成结束] 总耗时 {(time.time() - start_time):.1f}秒。")
-                return 
-            except GeneratorExit: 
+                        self._raise_for_deepseek_status(response)
+
+                    for raw_line in response.iter_lines(
+                        decode_unicode=True
+                    ):
+                        event = self._parse_sse_line(raw_line)
+                        if not event:
+                            continue
+                        if event.get("done"):
+                            break
+
+                        choices = event.get("choices") or []
+                        if not choices:
+                            continue
+
+                        delta = choices[0].get("delta") or {}
+                        reasoning_content = (
+                            delta.get("reasoning_content") or ""
+                        )
+                        content = delta.get("content") or ""
+
+                        if reasoning_content:
+                            reasoning_chunks += 1
+                            if not reasoning_open:
+                                reasoning_open = True
+                                logging.info(
+                                    "🧠 DeepSeek thinking started."
+                                )
+                                if self.deepseek_show_reasoning:
+                                    yield "\n<think>\n"
+
+                            if self.deepseek_show_reasoning:
+                                yield str(reasoning_content)
+                            else:
+                                yield ""
+
+                            if reasoning_chunks % 25 == 0:
+                                logging.info(
+                                    "⏳ DeepSeek thinking heartbeat: "
+                                    "%.1fs, %s chunks",
+                                    time.time() - start_time,
+                                    reasoning_chunks,
+                                )
+
+                        if content:
+                            if (
+                                reasoning_open
+                                and self.deepseek_show_reasoning
+                            ):
+                                yield "\n</think>\n\n"
+                            reasoning_open = False
+                            emitted_content = True
+                            yield str(content)
+
+                    if (
+                        reasoning_open
+                        and self.deepseek_show_reasoning
+                    ):
+                        yield "\n</think>\n"
+
+                if not emitted_content:
+                    raise DeepSeekAPIError(
+                        "DeepSeek stream ended without final content."
+                    )
+
+                logging.info(
+                    "✅ [流式生成结束] 总耗时=%.1fs",
+                    time.time() - start_time,
+                )
+                return
+
+            except GeneratorExit:
                 raise
-            except Exception as e:
-                logging.error(f"❌ [流式中断]: {e}")
-                if attempt == 2: 
-                    raise
-                time.sleep(2)
+            except (
+                DeepSeekAuthenticationError,
+                DeepSeekBalanceError,
+                DeepSeekRequestError,
+            ):
+                raise
+            except (
+                requests.exceptions.Timeout,
+                requests.exceptions.ConnectionError,
+                requests.exceptions.HTTPError,
+                DeepSeekAPIError,
+            ) as exc:
+                last_error = exc
+                logging.error(
+                    "❌ DeepSeek 流式尝试 %s/%s 失败: %s",
+                    attempt + 1,
+                    self.deepseek_max_retries,
+                    exc,
+                )
+
+                if emitted_content:
+                    raise DeepSeekAPIError(
+                        "DeepSeek stream was interrupted after partial "
+                        "content had already been emitted."
+                    ) from exc
+
+                is_last = attempt == self.deepseek_max_retries - 1
+                if is_last:
+                    break
+                time.sleep(self._retry_delay(attempt))
+
+        raise DeepSeekAPIError(
+            f"DeepSeek streaming failed after "
+            f"{self.deepseek_max_retries} attempts: {last_error}"
+        )
 
     def parse_user_core_literature(self, user_lit_text):
         if not user_lit_text.strip():