jarvis-ai-assistant 0.7.8__py3-none-any.whl → 1.0.2__py3-none-any.whl

jarvis/jarvis_agent/run_loop.py

@@ -7,55 +7,85 @@ AgentRunLoop: 承载 Agent 的主运行循环逻辑。
 - 暂不变更外部调用入口，后续在 Agent._main_loop 中委派到该类
 - 保持与现有异常处理、工具调用、用户交互完全一致
 """
+
 import os
 from enum import Enum
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Optional
+
+from rich import box
+from rich.panel import Panel
 
-from jarvis.jarvis_agent.events import BEFORE_TOOL_CALL, AFTER_TOOL_CALL
-from jarvis.jarvis_agent.utils import join_prompts, is_auto_complete, normalize_next_action
-from jarvis.jarvis_utils.config import get_max_input_token_count, get_conversation_turn_threshold
+from jarvis.jarvis_agent.events import AFTER_TOOL_CALL
+from jarvis.jarvis_agent.events import BEFORE_TOOL_CALL
+from jarvis.jarvis_agent.utils import is_auto_complete
+from jarvis.jarvis_agent.utils import join_prompts
+from jarvis.jarvis_agent.utils import normalize_next_action
+from jarvis.jarvis_utils.config import get_conversation_turn_threshold
+from jarvis.jarvis_utils.config import get_max_input_token_count
+from jarvis.jarvis_utils.output import PrettyOutput
+from jarvis.jarvis_utils.tag import ot
 
 if TYPE_CHECKING:
     # 仅用于类型标注，避免运行时循环依赖
-    from . import Agent  # noqa: F401
+    from . import Agent
 
 
 class AgentRunLoop:
     def __init__(self, agent: "Agent") -> None:
         self.agent = agent
-        self.conversation_rounds = 0
-        self.tool_reminder_rounds = int(os.environ.get("JARVIS_TOOL_REMINDER_ROUNDS", 20))
+        self.tool_reminder_rounds = int(os.environ.get("tool_reminder_rounds", 20))
         # 基于剩余token数量的自动总结阈值：当剩余token低于输入窗口的20%时触发
         max_input_tokens = get_max_input_token_count(self.agent.model_group)
         self.summary_remaining_token_threshold = int(max_input_tokens * 0.2)
         self.conversation_turn_threshold = get_conversation_turn_threshold()
 
+        # Git diff相关属性
+        self._git_diff: Optional[str] = None  # 缓存git diff内容
+
     def run(self) -> Any:
         """主运行循环（委派到传入的 agent 实例的方法与属性）"""
         run_input_handlers = True
 
         while True:
             try:
-                self.conversation_rounds += 1
-                if self.conversation_rounds % self.tool_reminder_rounds == 0:
+                current_round = self.agent.model.get_conversation_turn()
+                if current_round % self.tool_reminder_rounds == 0:
                     self.agent.session.addon_prompt = join_prompts(
-                        [self.agent.session.addon_prompt, self.agent.get_tool_usage_prompt()]
+                        [
+                            self.agent.session.addon_prompt,
+                            self.agent.get_tool_usage_prompt(),
+                        ]
                     )
                 # 基于剩余token数量或对话轮次的自动总结判断
                 remaining_tokens = self.agent.model.get_remaining_token_count()
                 should_summarize = (
-                    remaining_tokens <= self.summary_remaining_token_threshold or
-                    self.conversation_rounds > self.conversation_turn_threshold
+                    remaining_tokens <= self.summary_remaining_token_threshold
+                    or current_round > self.conversation_turn_threshold
                 )
                 if should_summarize:
+                    # 在总结前获取git diff（仅对CodeAgent类型）
+                    try:
+                        if (
+                            hasattr(self.agent, "start_commit")
+                            and self.agent.start_commit
+                        ):
+                            self._git_diff = self.get_git_diff()
+                        else:
+                            self._git_diff = None
+                    except Exception as e:
+                        PrettyOutput.auto_print(f"⚠️ 获取git diff失败: {str(e)}")
+                        self._git_diff = f"获取git diff失败: {str(e)}"
+
                     summary_text = self.agent._summarize_and_clear_history()
                     if summary_text:
                         # 将摘要作为下一轮的附加提示加入，从而维持上下文连续性
                         self.agent.session.addon_prompt = join_prompts(
                             [self.agent.session.addon_prompt, summary_text]
                         )
-                    # 重置轮次计数（用于工具提醒）与对话长度计数器（用于摘要触发），开始新一轮周期
-                    self.conversation_rounds = 0
+                    # 重置对话长度计数器（用于摘要触发），开始新一轮周期
+                    # 注意：对话轮次由模型内部管理，这里不需要重置
                     self.agent.session.conversation_length = 0
 
                 ag = self.agent
@@ -77,11 +107,23 @@ class AgentRunLoop:
                 ag.session.prompt = ""
                 run_input_handlers = False
 
-                # 检查是否包含 <!!!SUMMARY!!!> 标记，触发总结并清空历史
-                if "<!!!SUMMARY!!!>" in current_response:
-                    print("ℹ️ 检测到 <!!!SUMMARY!!!> 标记，正在触发总结并清空历史...")
+                if ot("!!!SUMMARY!!!") in current_response:
+                    PrettyOutput.auto_print(
+                        f"ℹ️ 检测到 {ot('!!!SUMMARY!!!')} 标记，正在触发总结并清空历史..."
+                    )
                     # 移除标记，避免在后续处理中出现
-                    current_response = current_response.replace("<!!!SUMMARY!!!>", "").strip()
+                    current_response = current_response.replace(
+                        ot("!!!SUMMARY!!!"), ""
+                    ).strip()
+                    # 在总结前获取git diff（仅对CodeAgent类型）
+                    try:
+                        if hasattr(ag, "start_commit") and ag.start_commit:
+                            self._git_diff = self.get_git_diff()
+                        else:
+                            self._git_diff = None
+                    except Exception as e:
+                        PrettyOutput.auto_print(f"⚠️ 获取git diff失败: {str(e)}")
+                        self._git_diff = f"获取git diff失败: {str(e)}"
                     # 触发总结并清空历史
                     summary_text = ag._summarize_and_clear_history()
                     if summary_text:
@@ -89,8 +131,8 @@ class AgentRunLoop:
                         ag.session.addon_prompt = join_prompts(
                             [ag.session.addon_prompt, summary_text]
                         )
-                    # 重置轮次计数（用于工具提醒）与对话长度计数器（用于摘要触发），开始新一轮周期
-                    self.conversation_rounds = 0
+                    # 重置对话长度计数器（用于摘要触发），开始新一轮周期
+                    # 注意：对话轮次由模型内部管理，这里不需要重置
                     ag.session.conversation_length = 0
                     # 如果响应中还有其他内容，继续处理；否则继续下一轮
                     if not current_response:
@@ -104,7 +146,9 @@ class AgentRunLoop:
                 ):
                     # 中断处理器请求跳过本轮剩余部分，直接开始下一次循环
                     continue
-                elif interrupt_result is not None and not isinstance(interrupt_result, Enum):
+                elif interrupt_result is not None and not isinstance(
+                    interrupt_result, Enum
+                ):
                     # 中断处理器返回了最终结果，任务结束
                     return interrupt_result
 
@@ -127,15 +171,17 @@ class AgentRunLoop:
 
                 # 将上一个提示和工具提示安全地拼接起来（仅当工具结果为字符串时）
                 safe_tool_prompt = tool_prompt if isinstance(tool_prompt, str) else ""
-                
+
                 ag.session.prompt = join_prompts([ag.session.prompt, safe_tool_prompt])
 
                 # 关键流程：直接调用 after_tool_call 回调函数
                 try:
                     # 获取所有订阅了 AFTER_TOOL_CALL 事件的回调
                     listeners = ag.event_bus._listeners.get(AFTER_TOOL_CALL, [])
-                    for callback in listeners:
+                    for listener_tuple in listeners:
                         try:
+                            # listener_tuple 是 (priority, order, callback)
+                            _, _, callback = listener_tuple
                             callback(
                                 agent=ag,
                                 current_response=current_response,
@@ -146,7 +192,7 @@ class AgentRunLoop:
                             pass
                 except Exception:
                     pass
-                
+
                 # 非关键流程：广播工具调用后的事件（用于日志、监控等）
                 try:
                     ag.event_bus.emit(
@@ -174,10 +220,9 @@ class AgentRunLoop:
                         return current_response
                     return result
 
-                
                 # 检查是否有工具调用：如果tool_prompt不为空，说明有工具被调用
                 has_tool_call = bool(safe_tool_prompt and safe_tool_prompt.strip())
-                
+
                 # 在非交互模式下，跟踪连续没有工具调用的次数
                 if ag.non_interactive:
                     if has_tool_call:
@@ -186,15 +231,28 @@ class AgentRunLoop:
                     else:
                         # 没有工具调用，增加计数器
                         ag._no_tool_call_count += 1
-                        # 如果连续5次没有工具调用，添加工具使用提示
-                        if ag._no_tool_call_count >= 5:
+                        # 如果连续3次没有工具调用，发送工具使用提示
+                        if ag._no_tool_call_count >= 3:
                             tool_usage_prompt = ag.get_tool_usage_prompt()
-                            ag.session.addon_prompt = join_prompts(
-                                [ag.session.addon_prompt, tool_usage_prompt]
-                            )
+                            ag.set_addon_prompt(tool_usage_prompt)
                             # 重置计数器，避免重复添加
                             ag._no_tool_call_count = 0
 
+                # 如果没有工具调用，显示完整响应
+                if not has_tool_call and current_response and current_response.strip():
+                    import jarvis.jarvis_utils.globals as G
+                    from jarvis.jarvis_utils.globals import console
+
+                    agent_name = ag.name if hasattr(ag, "name") else None
+                    panel = Panel(
+                        current_response,
+                        title=f"[bold cyan]{(G.get_current_agent_name() + ' · ') if G.get_current_agent_name() else ''}{agent_name or 'LLM'}[/bold cyan]",
+                        border_style="bright_blue",
+                        box=box.ROUNDED,
+                        expand=True,
+                    )
+                    console.print(panel)
+
                 # 获取下一步用户输入
                 next_action = ag._get_next_user_action()
                 action = normalize_next_action(next_action)
@@ -205,5 +263,107 @@ class AgentRunLoop:
                     return ag._complete_task(auto_completed=False)
 
             except Exception as e:
-                print(f"❌ 任务失败: {str(e)}")
+                PrettyOutput.auto_print(f"❌ 任务失败: {str(e)}")
                 return f"Task failed: {str(e)}"
+
+    def get_git_diff(self) -> str:
+        """获取从起始commit到当前commit的git diff
+
+        返回:
+            str: git diff内容，如果无法获取则返回错误信息
+        """
+        try:
+            from jarvis.jarvis_utils.git_utils import get_diff_between_commits
+            from jarvis.jarvis_utils.git_utils import get_latest_commit_hash
+
+            # 获取agent实例
+            agent = self.agent
+
+            # 检查agent是否有start_commit属性
+            if not hasattr(agent, "start_commit") or not agent.start_commit:
+                return "无法获取起始commit哈希值"
+
+            start_commit = agent.start_commit
+            current_commit = get_latest_commit_hash()
+
+            if not current_commit:
+                return "无法获取当前commit哈希值"
+
+            if start_commit == current_commit:
+                return (
+                    "# 没有检测到代码变更\n\n起始commit和当前commit相同，没有代码变更。"
+                )
+
+            # 获取diff
+            diff_content = get_diff_between_commits(start_commit, current_commit)
+
+            # 检查并处理token数量限制
+            model_group = agent.model_group
+            return self._check_diff_token_limit(diff_content, model_group)
+
+        except Exception as e:
+            return f"获取git diff失败: {str(e)}"
+
+    def get_cached_git_diff(self) -> Optional[str]:
+        """获取已缓存的git diff信息
+
+        返回:
+            Optional[str]: 已缓存的git diff内容，如果尚未获取则返回None
+        """
+        return self._git_diff
+
+    def has_git_diff(self) -> bool:
+        """检查是否有可用的git diff信息
+
+        返回:
+            bool: 如果有可用的git diff信息返回True，否则返回False
+        """
+        return self._git_diff is not None and bool(self._git_diff.strip())
+
+    def _check_diff_token_limit(
+        self, diff_content: str, model_group: Optional[str]
+    ) -> str:
+        """检查diff内容的token限制并返回适当的diff内容
+
+        参数:
+            diff_content: 原始的diff内容
+            model_group: 模型组名称，可为空
+
+        返回:
+            str: 处理后的diff内容（可能是原始内容或截断后的内容）
+        """
+        from jarvis.jarvis_utils.embedding import get_context_token_count
+
+        # 检查token数量限制
+        max_input_tokens = get_max_input_token_count(model_group)
+        # 预留一部分token用于其他内容，使用10%作为diff的限制
+        max_diff_tokens = int(max_input_tokens * 0.1)
+
+        diff_token_count = get_context_token_count(diff_content)
+
+        if diff_token_count <= max_diff_tokens:
+            return diff_content
+
+        # 如果diff内容太大，进行截断
+        lines = diff_content.split("\n")
+        truncated_lines = []
+        current_tokens = 0
+
+        for line in lines:
+            line_tokens = get_context_token_count(line)
+            if current_tokens + line_tokens > max_diff_tokens:
+                # 添加截断提示
+                truncated_lines.append("")
+                truncated_lines.append("# ⚠️ diff内容过大，已截断显示")
+                truncated_lines.append(
+                    f"# 原始diff共 {len(lines)} 行，{diff_token_count} tokens"
+                )
+                truncated_lines.append(
+                    f"# 显示前 {len(truncated_lines)} 行，约 {current_tokens} tokens"
+                )
+                break
+
+            truncated_lines.append(line)
+            current_tokens += line_tokens
+
+        return "\n".join(truncated_lines)

jarvis/jarvis_agent/session_manager.py

@@ -1,7 +1,11 @@
 # -*- coding: utf-8 -*-
 import os
-from typing import Any, Dict, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Dict
+from typing import Optional
 
+from jarvis.jarvis_utils.output import PrettyOutput
 
 if TYPE_CHECKING:
     from jarvis.jarvis_platform.base import BasePlatform
@@ -60,9 +64,9 @@ class SessionManager:
         if self.model.restore(session_file):
             try:
                 os.remove(session_file)
-                print("✅ 会话已恢复，并已删除会话文件。")
+                PrettyOutput.auto_print("✅ 会话已恢复，并已删除会话文件。")
             except OSError as e:
-                print(f"❌ 删除会话文件失败: {e}")
+                PrettyOutput.auto_print(f"❌ 删除会话文件失败: {e}")
             return True
         return False
 

jarvis/jarvis_agent/share_manager.py

@@ -1,14 +1,20 @@
 # -*- coding: utf-8 -*-
 """分享管理模块，负责工具和方法论的分享功能"""
+
 import os
 import subprocess
-from typing import List, Dict, Any, Set
-from abc import ABC, abstractmethod
+from abc import ABC
+from abc import abstractmethod
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Set
 
 from prompt_toolkit import prompt
 
 from jarvis.jarvis_agent import user_confirm
 from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.output import PrettyOutput
 
 
 def parse_selection(selection_str: str, max_value: int) -> List[int]:
@@ -61,7 +67,7 @@ class ShareManager(ABC):
     def update_central_repo(self) -> None:
         """克隆或更新中心仓库"""
         if not os.path.exists(self.repo_path):
-            print(f"ℹ️ 正在克隆中心{self.get_resource_type()}仓库...")
+            PrettyOutput.auto_print(f"ℹ️ 正在克隆中心{self.get_resource_type()}仓库...")
             subprocess.run(
                 ["git", "clone", self.central_repo_url, self.repo_path], check=True
             )
@@ -90,7 +96,7 @@ class ShareManager(ABC):
                 )
                 subprocess.run(["git", "push"], cwd=self.repo_path, check=True)
         else:
-            print(f"ℹ️ 正在更新中心{self.get_resource_type()}仓库...")
+            PrettyOutput.auto_print(f"ℹ️ 正在更新中心{self.get_resource_type()}仓库...")
             # 检查是否是空仓库
             try:
                 # 先尝试获取远程分支信息
@@ -119,18 +125,22 @@ class ShareManager(ABC):
                                 ["git", "checkout", "."], cwd=self.repo_path, check=True
                             )
                         else:
-                            print(f"ℹ️ 跳过更新 '{self.repo_name}' 以保留未提交的更改。")
+                            PrettyOutput.auto_print(
+                                f"ℹ️ 跳过更新 '{self.repo_name}' 以保留未提交的更改。"
+                            )
                             return
                     subprocess.run(["git", "pull"], cwd=self.repo_path, check=True)
                 else:
-                    print(f"ℹ️ 中心{self.get_resource_type()}仓库是空的，将初始化为新仓库")
+                    PrettyOutput.auto_print(
+                        f"ℹ️ 中心{self.get_resource_type()}仓库是空的，将初始化为新仓库"
+                    )
             except subprocess.CalledProcessError:
                 # 如果命令失败，可能是网络问题或其他错误
-                print("⚠️ 无法连接到远程仓库，将跳过更新")
+                PrettyOutput.auto_print("⚠️ 无法连接到远程仓库，将跳过更新")
 
     def commit_and_push(self, count: int) -> None:
         """提交并推送更改"""
-        print("ℹ️ 正在提交更改...")
+        PrettyOutput.auto_print("ℹ️ 正在提交更改...")
         subprocess.run(["git", "add", "."], cwd=self.repo_path, check=True)
 
         commit_msg = f"Add {count} {self.get_resource_type()}(s) from local collection"
@@ -138,7 +148,7 @@ class ShareManager(ABC):
             ["git", "commit", "-m", commit_msg], cwd=self.repo_path, check=True
         )
 
-        print("ℹ️ 正在推送到远程仓库...")
+        PrettyOutput.auto_print("ℹ️ 正在推送到远程仓库...")
         # 检查是否需要设置上游分支（空仓库的情况）
         try:
             # 先尝试普通推送
@@ -169,8 +179,8 @@ class ShareManager(ABC):
             resource_list.append(f"[{i}] {self.format_resource_display(resource)}")
 
         # 一次性打印所有资源
-        joined_resources = '\n'.join(resource_list)
-        print(f"ℹ️ {joined_resources}")
+        joined_resources = "\n".join(resource_list)
+        PrettyOutput.auto_print(f"ℹ️ {joined_resources}")
 
         # 让用户选择
         while True:
@@ -186,12 +196,12 @@ class ShareManager(ABC):
                 else:
                     selected_indices = parse_selection(choice_str, len(resources))
                     if not selected_indices:
-                        print("⚠️ 无效的选择")
+                        PrettyOutput.auto_print("⚠️ 无效的选择")
                         continue
                     return [resources[i - 1] for i in selected_indices]
 
             except ValueError:
-                print("⚠️ 请输入有效的数字")
+                PrettyOutput.auto_print("⚠️ 请输入有效的数字")
 
     @abstractmethod
     def get_resource_type(self) -> str:

jarvis/jarvis_agent/shell_input_handler.py

@@ -1,8 +1,10 @@
 # -*- coding: utf-8 -*-
-from typing import Any, Tuple
+from typing import Any
+from typing import Tuple
 
-from jarvis.jarvis_utils.input import user_confirm
 from jarvis.jarvis_agent.utils import join_prompts
+from jarvis.jarvis_utils.input import user_confirm
+from jarvis.jarvis_utils.output import PrettyOutput
 
 
 def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
@@ -23,7 +25,7 @@ def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
 
         # Build script while stripping the no-confirm marker from each line
         script = "\n".join([_clean(c) for c in cmdline])
-        print(script)
+        PrettyOutput.auto_print(script)
 
         # If any line contains the no-confirm marker, skip the pre-execution confirmation
         no_confirm = any(marker in c for c in cmdline)
@@ -41,11 +43,13 @@ def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
             )
             if user_confirm("是否将执行结果反馈给Agent？", default=True):
                 return (
-                    join_prompts([
-                        user_input,
-                        f"用户执行以下脚本：\n{script}",
-                        f"执行结果：\n{output}",
-                    ]),
+                    join_prompts(
+                        [
+                            user_input,
+                            f"用户执行以下脚本：\n{script}",
+                            f"执行结果：\n{output}",
+                        ]
+                    ),
                     False,
                 )
             return "", True

jarvis/jarvis_agent/stdio_redirect.py

@@ -2,7 +2,7 @@
 """
 Web STDIO 重定向模块：
 - 在 Web 模式下，将 Python 层的标准输出/错误（sys.stdout/sys.stderr）重定向到 WebSocket，通过 WebBridge 广播。
-- 适用于工具或第三方库直接使用 print()/stdout/stderr 的输出，从而不经过 PrettyOutput Sink 的场景。
+- 适用于工具或第三方库直接使用 PrettyOutput.auto_print()/stdout/stderr 的输出，从而不经过 PrettyOutput Sink 的场景。
 
 注意：
 - 这是进程级重定向，可能带来重复输出（PrettyOutput 已通过 Sink 广播一次，console.print 也会走到 stdout）。若需要避免重复，可在前端针对 'stdio' 类型进行独立显示或折叠。
@@ -17,14 +17,15 @@ Web STDIO 重定向模块：
   # ... 运行期间输出将通过 WS 广播 ...
   disable_web_stdio_redirect()
 """
+
 from __future__ import annotations
 
 import sys
 import threading
+from typing import Optional
 
 from jarvis.jarvis_agent.web_bridge import WebBridge
 
-
 _original_stdout = sys.stdout
 _original_stderr = sys.stderr
 _redirect_enabled = False
@@ -47,11 +48,13 @@ class _WebStreamWrapper:
         except Exception:
             text = repr(s)
         try:
-            WebBridge.instance().broadcast({
-                "type": "stdio",
-                "stream": self._stream_name,
-                "text": text,
-            })
+            WebBridge.instance().broadcast(
+                {
+                    "type": "stdio",
+                    "stream": self._stream_name,
+                    "text": text,
+                }
+            )
         except Exception:
             # 广播异常不影响主流程
             pass
@@ -79,7 +82,10 @@ class _WebStreamWrapper:
     def __getattr__(self, name: str):
         # 兼容性：必要时委派到原始 stdout/stderr 的属性（尽量避免）
         try:
-            return getattr(_original_stdout if self._stream_name == "stdout" else _original_stderr, name)
+            return getattr(
+                _original_stdout if self._stream_name == "stdout" else _original_stderr,
+                name,
+            )
         except Exception:
             raise AttributeError(name)
 
@@ -91,8 +97,8 @@ def enable_web_stdio_redirect() -> None:
         if _redirect_enabled:
             return
         try:
-            sys.stdout = _WebStreamWrapper("stdout")  # type: ignore[assignment]
-            sys.stderr = _WebStreamWrapper("stderr")  # type: ignore[assignment]
+            sys.stdout = _WebStreamWrapper("stdout")
+            sys.stderr = _WebStreamWrapper("stderr")
             _redirect_enabled = True
         except Exception:
             # 回退：保持原始输出
@@ -122,10 +128,9 @@ def disable_web_stdio_redirect() -> None:
 # - 仅适用于部分交互式场景（非真正 PTY 行为），可满足基础行缓冲输入
 from queue import Queue  # noqa: E402
 
-
 _original_stdin = sys.stdin
 _stdin_enabled = False
-_stdin_wrapper = None  # type: ignore[assignment]
+_stdin_wrapper: Optional[_WebInputWrapper] = None
 
 
 class _WebInputWrapper:
@@ -136,7 +141,7 @@ class _WebInputWrapper:
         self._buffer: str = ""
         self._lock = threading.Lock()
         try:
-            self._encoding = getattr(_original_stdin, "encoding", "utf-8")  # type: ignore[name-defined]
+            self._encoding = getattr(_original_stdin, "encoding", "utf-8")
         except Exception:
             self._encoding = "utf-8"
 
@@ -172,10 +177,7 @@ class _WebInputWrapper:
             except Exception:
                 chunk = ""
             if not isinstance(chunk, str):
-                try:
-                    chunk = str(chunk)
-                except Exception:
-                    chunk = ""
+                chunk = str(chunk)  # type: ignore
             with self._lock:
                 self._buffer += chunk
 
@@ -203,10 +205,7 @@ class _WebInputWrapper:
             except Exception:
                 chunk = ""
             if not isinstance(chunk, str):
-                try:
-                    chunk = str(chunk)
-                except Exception:
-                    chunk = ""
+                chunk = str(chunk)  # type: ignore
             with self._lock:
                 self._buffer += chunk
 
@@ -260,14 +259,14 @@ def enable_web_stdin_redirect() -> None:
         try:
             # 记录原始 stdin（若尚未记录）
             if "_original_stdin" not in globals() or _original_stdin is None:
-                _original_stdin = sys.stdin  # type: ignore[assignment]
+                _original_stdin = sys.stdin
             _stdin_wrapper = _WebInputWrapper()
-            sys.stdin = _stdin_wrapper  # type: ignore[assignment]
+            sys.stdin = _stdin_wrapper
             _stdin_enabled = True
         except Exception:
             # 回退：保持原始输入
             try:
-                sys.stdin = _original_stdin  # type: ignore[assignment]
+                sys.stdin = _original_stdin
             except Exception:
                 pass
             _stdin_enabled = False
@@ -278,7 +277,7 @@ def disable_web_stdin_redirect() -> None:
     global _stdin_enabled, _stdin_wrapper
     with _lock:
         try:
-            sys.stdin = _original_stdin  # type: ignore[assignment]
+            sys.stdin = _original_stdin
         except Exception:
             pass
         _stdin_wrapper = None
@@ -289,7 +288,7 @@ def feed_web_stdin(data: str) -> None:
     """向 Web STDIN 注入数据（由 WebSocket /stdio 端点调用）。"""
     try:
         if _stdin_enabled and _stdin_wrapper is not None:
-            _stdin_wrapper.feed(data)  # type: ignore[attr-defined]
+            _stdin_wrapper.feed(data)
     except Exception:
         # 注入失败不影响主流程
         pass