jarvis-ai-assistant 0.3.30__py3-none-any.whl → 0.7.6__py3-none-any.whl

jarvis/jarvis_agent/run_loop.py

@@ -7,12 +7,13 @@ AgentRunLoop: 承载 Agent 的主运行循环逻辑。
 - 暂不变更外部调用入口，后续在 Agent._main_loop 中委派到该类
 - 保持与现有异常处理、工具调用、用户交互完全一致
 """
+import os
 from enum import Enum
 from typing import Any, TYPE_CHECKING
 
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 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
 
 if TYPE_CHECKING:
     # 仅用于类型标注，避免运行时循环依赖
@@ -22,6 +23,12 @@ if TYPE_CHECKING:
 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))
+        # 基于剩余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()
 
     def run(self) -> Any:
         """主运行循环（委派到传入的 agent 实例的方法与属性）"""
@@ -29,6 +36,28 @@ class AgentRunLoop:
 
         while True:
             try:
+                self.conversation_rounds += 1
+                if self.conversation_rounds % self.tool_reminder_rounds == 0:
+                    self.agent.session.addon_prompt = join_prompts(
+                        [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
+                )
+                if should_summarize:
+                    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
 
                 # 更新输入处理器标志
@@ -48,6 +77,25 @@ class AgentRunLoop:
                 ag.session.prompt = ""
                 run_input_handlers = False
 
+                # 检查是否包含 <!!!SUMMARY!!!> 标记，触发总结并清空历史
+                if "<!!!SUMMARY!!!>" in current_response:
+                    print("ℹ️ 检测到 <!!!SUMMARY!!!> 标记，正在触发总结并清空历史...")
+                    # 移除标记，避免在后续处理中出现
+                    current_response = current_response.replace("<!!!SUMMARY!!!>", "").strip()
+                    # 触发总结并清空历史
+                    summary_text = ag._summarize_and_clear_history()
+                    if summary_text:
+                        # 将摘要作为下一轮的附加提示加入，从而维持上下文连续性
+                        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:
+                        continue
+
                 # 处理中断
                 interrupt_result = ag._handle_run_interrupt(current_response)
                 if (
@@ -61,7 +109,7 @@ class AgentRunLoop:
                     return interrupt_result
 
                 # 处理工具调用
-                # 广播工具调用前事件（不影响主流程）
+                # 非关键流程：广播工具调用前事件（用于日志、监控等）
                 try:
                     ag.event_bus.emit(
                         BEFORE_TOOL_CALL,
@@ -72,14 +120,34 @@ class AgentRunLoop:
                     pass
                 need_return, tool_prompt = ag._call_tools(current_response)
 
-                # 将上一个提示和工具提示安全地拼接起来
-                ag.session.prompt = join_prompts([ag.session.prompt, tool_prompt])
-
+                # 如果工具要求立即返回结果（例如 SEND_MESSAGE 需要将字典返回给上层），直接返回该结果
                 if need_return:
-                    return ag.session.prompt
+                    ag._no_tool_call_count = 0
+                    return tool_prompt
 
+                # 将上一个提示和工具提示安全地拼接起来（仅当工具结果为字符串时）
+                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:
+                        try:
+                            callback(
+                                agent=ag,
+                                current_response=current_response,
+                                need_return=need_return,
+                                tool_prompt=tool_prompt,
+                            )
+                        except Exception:
+                            pass
+                except Exception:
+                    pass
+                
+                # 非关键流程：广播工具调用后的事件（用于日志、监控等）
                 try:
                     ag.event_bus.emit(
                         AFTER_TOOL_CALL,
@@ -93,11 +161,39 @@ class AgentRunLoop:
 
                 # 检查是否需要继续
                 if ag.session.prompt or ag.session.addon_prompt:
+                    ag._no_tool_call_count = 0
                     continue
 
                 # 检查自动完成
                 if ag.auto_complete and is_auto_complete(current_response):
-                    return ag._complete_task(auto_completed=True)
+                    ag._no_tool_call_count = 0
+                    # 先运行_complete_task，触发记忆整理/事件等副作用，再决定返回值
+                    result = ag._complete_task(auto_completed=True)
+                    # 若不需要summary，则将最后一条LLM输出作为返回值
+                    if not getattr(ag, "need_summary", True):
+                        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:
+                        # 有工具调用，重置计数器
+                        ag._no_tool_call_count = 0
+                    else:
+                        # 没有工具调用，增加计数器
+                        ag._no_tool_call_count += 1
+                        # 如果连续5次没有工具调用，添加工具使用提示
+                        if ag._no_tool_call_count >= 5:
+                            tool_usage_prompt = ag.get_tool_usage_prompt()
+                            ag.session.addon_prompt = join_prompts(
+                                [ag.session.addon_prompt, tool_usage_prompt]
+                            )
+                            # 重置计数器，避免重复添加
+                            ag._no_tool_call_count = 0
 
                 # 获取下一步用户输入
                 next_action = ag._get_next_user_action()
@@ -109,5 +205,5 @@ class AgentRunLoop:
                     return ag._complete_task(auto_completed=False)
 
             except Exception as e:
-                PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
+                print(f"❌ 任务失败: {str(e)}")
                 return f"Task failed: {str(e)}"

jarvis/jarvis_agent/session_manager.py

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

jarvis/jarvis_agent/share_manager.py

@@ -7,7 +7,7 @@ from abc import ABC, abstractmethod
 
 from prompt_toolkit import prompt
 
-from jarvis.jarvis_agent import OutputType, PrettyOutput, user_confirm
+from jarvis.jarvis_agent import user_confirm
 from jarvis.jarvis_utils.config import get_data_dir
 
 
@@ -49,14 +49,19 @@ class ShareManager(ABC):
     def __init__(self, central_repo_url: str, repo_name: str):
         self.central_repo_url = central_repo_url
         self.repo_name = repo_name
-        self.repo_path = os.path.join(get_data_dir(), repo_name)
+        # 支持将中心仓库配置为本地目录（含git子路径）
+        expanded = os.path.expanduser(os.path.expandvars(central_repo_url))
+        if os.path.isdir(expanded):
+            # 直接使用本地目录作为中心仓库路径（支持git仓库子目录）
+            self.repo_path = expanded
+        else:
+            # 仍按原逻辑使用数据目录中的克隆路径
+            self.repo_path = os.path.join(get_data_dir(), repo_name)
 
     def update_central_repo(self) -> None:
         """克隆或更新中心仓库"""
         if not os.path.exists(self.repo_path):
-            PrettyOutput.print(
-                f"正在克隆中心{self.get_resource_type()}仓库...", OutputType.INFO
-            )
+            print(f"ℹ️ 正在克隆中心{self.get_resource_type()}仓库...")
             subprocess.run(
                 ["git", "clone", self.central_repo_url, self.repo_path], check=True
             )
@@ -85,9 +90,7 @@ class ShareManager(ABC):
                 )
                 subprocess.run(["git", "push"], cwd=self.repo_path, check=True)
         else:
-            PrettyOutput.print(
-                f"正在更新中心{self.get_resource_type()}仓库...", OutputType.INFO
-            )
+            print(f"ℹ️ 正在更新中心{self.get_resource_type()}仓库...")
             # 检查是否是空仓库
             try:
                 # 先尝试获取远程分支信息
@@ -116,24 +119,18 @@ class ShareManager(ABC):
                                 ["git", "checkout", "."], cwd=self.repo_path, check=True
                             )
                         else:
-                            PrettyOutput.print(
-                                f"跳过更新 '{self.repo_name}' 以保留未提交的更改。",
-                                OutputType.INFO,
-                            )
+                            print(f"ℹ️ 跳过更新 '{self.repo_name}' 以保留未提交的更改。")
                             return
                     subprocess.run(["git", "pull"], cwd=self.repo_path, check=True)
                 else:
-                    PrettyOutput.print(
-                        f"中心{self.get_resource_type()}仓库是空的，将初始化为新仓库",
-                        OutputType.INFO,
-                    )
+                    print(f"ℹ️ 中心{self.get_resource_type()}仓库是空的，将初始化为新仓库")
             except subprocess.CalledProcessError:
                 # 如果命令失败，可能是网络问题或其他错误
-                PrettyOutput.print("无法连接到远程仓库，将跳过更新", OutputType.WARNING)
+                print("⚠️ 无法连接到远程仓库，将跳过更新")
 
     def commit_and_push(self, count: int) -> None:
         """提交并推送更改"""
-        PrettyOutput.print("\n正在提交更改...", OutputType.INFO)
+        print("ℹ️ 正在提交更改...")
         subprocess.run(["git", "add", "."], cwd=self.repo_path, check=True)
 
         commit_msg = f"Add {count} {self.get_resource_type()}(s) from local collection"
@@ -141,7 +138,7 @@ class ShareManager(ABC):
             ["git", "commit", "-m", commit_msg], cwd=self.repo_path, check=True
         )
 
-        PrettyOutput.print("正在推送到远程仓库...", OutputType.INFO)
+        print("ℹ️ 正在推送到远程仓库...")
         # 检查是否需要设置上游分支（空仓库的情况）
         try:
             # 先尝试普通推送
@@ -172,7 +169,8 @@ class ShareManager(ABC):
             resource_list.append(f"[{i}] {self.format_resource_display(resource)}")
 
         # 一次性打印所有资源
-        PrettyOutput.print("\n".join(resource_list), OutputType.INFO)
+        joined_resources = '\n'.join(resource_list)
+        print(f"ℹ️ {joined_resources}")
 
         # 让用户选择
         while True:
@@ -188,12 +186,12 @@ class ShareManager(ABC):
                 else:
                     selected_indices = parse_selection(choice_str, len(resources))
                     if not selected_indices:
-                        PrettyOutput.print("无效的选择", OutputType.WARNING)
+                        print("⚠️ 无效的选择")
                         continue
                     return [resources[i - 1] for i in selected_indices]
 
             except ValueError:
-                PrettyOutput.print("请输入有效的数字", OutputType.WARNING)
+                print("⚠️ 请输入有效的数字")
 
     @abstractmethod
     def get_resource_type(self) -> str:

jarvis/jarvis_agent/shell_input_handler.py

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 from typing import Any, Tuple
 
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.input import user_confirm
 from jarvis.jarvis_agent.utils import join_prompts
 
@@ -24,7 +23,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])
-        PrettyOutput.print(script, OutputType.CODE, lang="bash")
+        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)

jarvis/jarvis_agent/stdio_redirect.py

@@ -0,0 +1,295 @@
+# -*- coding: utf-8 -*-
+"""
+Web STDIO 重定向模块：
+- 在 Web 模式下，将 Python 层的标准输出/错误（sys.stdout/sys.stderr）重定向到 WebSocket，通过 WebBridge 广播。
+- 适用于工具或第三方库直接使用 print()/stdout/stderr 的输出，从而不经过 PrettyOutput Sink 的场景。
+
+注意：
+- 这是进程级重定向，可能带来重复输出（PrettyOutput 已通过 Sink 广播一次，console.print 也会走到 stdout）。若需要避免重复，可在前端针对 'stdio' 类型进行独立显示或折叠。
+- 对于子进程输出（subprocess），通常由调用方决定是否捕获和打印；若直接透传到父进程的 stdout/stderr，也会被此重定向捕获。
+
+前端消息结构（通过 WebBridge.broadcast）：
+  { "type": "stdio", "stream": "stdout" | "stderr", "text": "..." }
+
+使用：
+  from jarvis.jarvis_agent.stdio_redirect import enable_web_stdio_redirect, disable_web_stdio_redirect
+  enable_web_stdio_redirect()
+  # ... 运行期间输出将通过 WS 广播 ...
+  disable_web_stdio_redirect()
+"""
+from __future__ import annotations
+
+import sys
+import threading
+
+from jarvis.jarvis_agent.web_bridge import WebBridge
+
+
+_original_stdout = sys.stdout
+_original_stderr = sys.stderr
+_redirect_enabled = False
+_lock = threading.Lock()
+
+
+class _WebStreamWrapper:
+    """文件类兼容包装器，将 write() 的内容通过 WebBridge 广播。"""
+
+    def __init__(self, stream_name: str) -> None:
+        self._stream_name = stream_name
+        try:
+            self._encoding = getattr(_original_stdout, "encoding", "utf-8")
+        except Exception:
+            self._encoding = "utf-8"
+
+    def write(self, s: object) -> int:
+        try:
+            text = s if isinstance(s, str) else str(s)
+        except Exception:
+            text = repr(s)
+        try:
+            WebBridge.instance().broadcast({
+                "type": "stdio",
+                "stream": self._stream_name,
+                "text": text,
+            })
+        except Exception:
+            # 广播异常不影响主流程
+            pass
+        # 返回写入长度以兼容部分调用方
+        try:
+            return len(text)
+        except Exception:
+            return 0
+
+    def flush(self) -> None:
+        # 无需实际刷新；保持接口兼容
+        pass
+
+    def isatty(self) -> bool:
+        return False
+
+    @property
+    def encoding(self) -> str:
+        return self._encoding
+
+    def writelines(self, lines) -> None:
+        for ln in lines:
+            self.write(ln)
+
+    def __getattr__(self, name: str):
+        # 兼容性：必要时委派到原始 stdout/stderr 的属性（尽量避免）
+        try:
+            return getattr(_original_stdout if self._stream_name == "stdout" else _original_stderr, name)
+        except Exception:
+            raise AttributeError(name)
+
+
+def enable_web_stdio_redirect() -> None:
+    """启用全局 STDOUT/STDERR 到 WebSocket 的重定向。"""
+    global _redirect_enabled
+    with _lock:
+        if _redirect_enabled:
+            return
+        try:
+            sys.stdout = _WebStreamWrapper("stdout")  # type: ignore[assignment]
+            sys.stderr = _WebStreamWrapper("stderr")  # type: ignore[assignment]
+            _redirect_enabled = True
+        except Exception:
+            # 回退：保持原始输出
+            sys.stdout = _original_stdout
+            sys.stderr = _original_stderr
+            _redirect_enabled = False
+
+
+def disable_web_stdio_redirect() -> None:
+    """禁用全局 STDOUT/STDERR 重定向，恢复原始输出。"""
+    global _redirect_enabled
+    with _lock:
+        try:
+            sys.stdout = _original_stdout
+            sys.stderr = _original_stderr
+        except Exception:
+            pass
+        _redirect_enabled = False
+
+
+# ---------------------------
+# Web STDIN 重定向（浏览器 -> 后端）
+# ---------------------------
+# 目的：
+# - 将前端 xterm 的按键数据通过 WS 送回服务端，并作为 sys.stdin 的数据源
+# - 使得 Python 层的 input()/sys.stdin.readline() 等可以从浏览器获得输入
+# - 仅适用于部分交互式场景（非真正 PTY 行为），可满足基础行缓冲输入
+from queue import Queue  # noqa: E402
+
+
+_original_stdin = sys.stdin
+_stdin_enabled = False
+_stdin_wrapper = None  # type: ignore[assignment]
+
+
+class _WebInputWrapper:
+    """文件类兼容包装器：作为 sys.stdin 的替身，从队列中读取浏览器送来的数据。"""
+
+    def __init__(self) -> None:
+        self._queue: "Queue[str]" = Queue()
+        self._buffer: str = ""
+        self._lock = threading.Lock()
+        try:
+            self._encoding = getattr(_original_stdin, "encoding", "utf-8")  # type: ignore[name-defined]
+        except Exception:
+            self._encoding = "utf-8"
+
+    # 外部注入：由 WebSocket 端点调用
+    def feed(self, data: str) -> None:
+        try:
+            s = data if isinstance(data, str) else str(data)
+        except Exception:
+            s = repr(data)
+        # 将回车转换为换行，方便基于 readline 的读取
+        s = s.replace("\r", "\n")
+        self._queue.put_nowait(s)
+
+    # 基础读取：尽可能兼容常用调用
+    def read(self, size: int = -1) -> str:
+        # size < 0 表示尽可能多地读取（直到当前缓冲区内容）
+        if size == 0:
+            return ""
+
+        while True:
+            with self._lock:
+                if size > 0 and len(self._buffer) >= size:
+                    out = self._buffer[:size]
+                    self._buffer = self._buffer[size:]
+                    return out
+                if size < 0 and self._buffer:
+                    out = self._buffer
+                    self._buffer = ""
+                    return out
+            # 需要更多数据，阻塞等待
+            try:
+                chunk = self._queue.get(timeout=None)
+            except Exception:
+                chunk = ""
+            if not isinstance(chunk, str):
+                try:
+                    chunk = str(chunk)
+                except Exception:
+                    chunk = ""
+            with self._lock:
+                self._buffer += chunk
+
+    def readline(self, size: int = -1) -> str:
+        # 读取到换行符为止（包含换行），可选 size 限制
+        while True:
+            with self._lock:
+                idx = self._buffer.find("\n")
+                if idx != -1:
+                    # 找到换行
+                    end_index = idx + 1
+                    if size > 0:
+                        end_index = min(end_index, size)
+                    out = self._buffer[:end_index]
+                    self._buffer = self._buffer[end_index:]
+                    return out
+                # 未找到换行，但如果指定了 size 且缓冲已有足够数据，则返回
+                if size > 0 and len(self._buffer) >= size:
+                    out = self._buffer[:size]
+                    self._buffer = self._buffer[size:]
+                    return out
+            # 更多数据
+            try:
+                chunk = self._queue.get(timeout=None)
+            except Exception:
+                chunk = ""
+            if not isinstance(chunk, str):
+                try:
+                    chunk = str(chunk)
+                except Exception:
+                    chunk = ""
+            with self._lock:
+                self._buffer += chunk
+
+    def readlines(self, hint: int = -1):
+        lines = []
+        total = 0
+        while True:
+            ln = self.readline()
+            if not ln:
+                break
+            lines.append(ln)
+            total += len(ln)
+            if hint > 0 and total >= hint:
+                break
+        return lines
+
+    def writable(self) -> bool:
+        return False
+
+    def readable(self) -> bool:
+        return True
+
+    def seekable(self) -> bool:
+        return False
+
+    def flush(self) -> None:
+        pass
+
+    def isatty(self) -> bool:
+        # 伪装为 TTY，可改善部分库的行为（注意并非真正 PTY）
+        return True
+
+    @property
+    def encoding(self) -> str:
+        return self._encoding
+
+    def __getattr__(self, name: str):
+        # 尽量代理到原始 stdin 的属性以增强兼容性
+        try:
+            return getattr(_original_stdin, name)
+        except Exception:
+            raise AttributeError(name)
+
+
+def enable_web_stdin_redirect() -> None:
+    """启用 Web STDIN 重定向：将 sys.stdin 替换为浏览器数据源。"""
+    global _stdin_enabled, _stdin_wrapper, _original_stdin
+    with _lock:
+        if _stdin_enabled:
+            return
+        try:
+            # 记录原始 stdin（若尚未记录）
+            if "_original_stdin" not in globals() or _original_stdin is None:
+                _original_stdin = sys.stdin  # type: ignore[assignment]
+            _stdin_wrapper = _WebInputWrapper()
+            sys.stdin = _stdin_wrapper  # type: ignore[assignment]
+            _stdin_enabled = True
+        except Exception:
+            # 回退：保持原始输入
+            try:
+                sys.stdin = _original_stdin  # type: ignore[assignment]
+            except Exception:
+                pass
+            _stdin_enabled = False
+
+
+def disable_web_stdin_redirect() -> None:
+    """禁用 Web STDIN 重定向，恢复原始输入。"""
+    global _stdin_enabled, _stdin_wrapper
+    with _lock:
+        try:
+            sys.stdin = _original_stdin  # type: ignore[assignment]
+        except Exception:
+            pass
+        _stdin_wrapper = None
+        _stdin_enabled = False
+
+
+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]
+    except Exception:
+        # 注入失败不影响主流程
+        pass