jarvis-ai-assistant 0.1.222__py3-none-any.whl → 0.7.0__py3-none-any.whl

jarvis/jarvis_multi_agent/main.py

@@ -1,27 +1,61 @@
 # -*- coding: utf-8 -*-
-import yaml
+from typing import Optional
+
+import typer
+import yaml  # type: ignore[import-untyped]
+import os
 
 from jarvis.jarvis_multi_agent import MultiAgent
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.utils import init_env
+from jarvis.jarvis_utils.config import set_config
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
+app = typer.Typer(help="多智能体系统启动器")
 
-def main():
-    """从YAML配置文件初始化并运行多智能体系统
 
-    Returns:
-        最终处理结果
-    """
+@app.command()
+def cli(
+    config: str = typer.Option(..., "--config", "-c", help="YAML配置文件路径"),
+    user_input: Optional[str] = typer.Option(
+        None, "--input", "-i", help="用户输入（可选）"
+    ),
+    model_group: Optional[str] = typer.Option(
+        None, "-g", "--llm-group", help="使用的模型组，覆盖配置文件中的设置"
+    ),
+    non_interactive: bool = typer.Option(
+        False, "-n", "--non-interactive", help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟"
+    ),
+):
+    """从YAML配置文件初始化并运行多智能体系统"""
+    # CLI 标志：非交互模式（不依赖配置文件）
+    if non_interactive:
+        try:
+            os.environ["JARVIS_NON_INTERACTIVE"] = "true"
+        except Exception:
+            pass
+        # 注意：全局配置同步在 init_env 之后执行，避免被覆盖
+    # 非交互模式要求从命令行传入任务
+    if non_interactive and not (user_input and str(user_input).strip()):
+        PrettyOutput.print(
+            "非交互模式已启用：必须使用 --input 传入任务内容，因多行输入不可用。",
+            OutputType.ERROR,
+        )
+        raise typer.Exit(code=2)
     init_env("欢迎使用 Jarvis-MultiAgent，您的多智能体系统已准备就绪！")
-    import argparse
-
-    parser = argparse.ArgumentParser(description="多智能体系统启动器")
-    parser.add_argument("--config", "-c", required=True, help="YAML配置文件路径")
-    parser.add_argument("--input", "-i", help="用户输入（可选）")
-    args = parser.parse_args()
+    
+    # 在初始化环境后同步 CLI 选项到全局配置，避免被 init_env 覆盖
+    try:
+        if non_interactive:
+            set_config("JARVIS_NON_INTERACTIVE", True)
+        if model_group:
+            set_config("JARVIS_LLM_GROUP", str(model_group))
+    except Exception:
+        # 静默忽略同步异常，不影响主流程
+        pass
 
     try:
-        with open(args.config, "r", errors="ignore") as f:
+        with open(config, "r", errors="ignore") as f:
             config_data = yaml.safe_load(f)
 
         # 获取agents配置
@@ -32,21 +66,33 @@ def main():
             raise ValueError("必须指定main_agent作为主智能体")
 
         # 创建并运行多智能体系统
-        multi_agent = MultiAgent(agents_config, main_agent_name)
-        user_input = (
-            args.input
-            if args.input is not None
+        multi_agent = MultiAgent(
+            agents_config,
+            main_agent_name,
+            common_system_prompt=str(config_data.get("common_system_prompt", "") or "")
+        )
+        final_input = (
+            user_input
+            if user_input is not None
             else get_multiline_input("请输入内容（输入空行结束）：")
         )
-        if user_input == "":
+        if not final_input:
             return
-        return multi_agent.run(user_input)
+        multi_agent.run(final_input)
+
+    except KeyboardInterrupt:
+        return
+    except typer.Exit:
+        return
+    except (ValueError, RuntimeError, yaml.YAMLError) as e:
+        PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
+        raise typer.Exit(code=1)
+
 
-    except yaml.YAMLError as e:
-        raise ValueError(f"YAML配置文件解析错误: {str(e)}")
-    except Exception as e:
-        raise RuntimeError(f"多智能体系统初始化失败: {str(e)}")
+def main() -> None:
+    """Application entry point."""
+    app()
 
 
 if __name__ == "__main__":
-    result = main()
+    main()

jarvis/jarvis_platform/ai8.py

@@ -32,22 +32,24 @@ class AI8Model(BasePlatform):
 
         self.headers = {
             "Authorization": self.token,
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-ch-ua": '"Not)A;Brand";v="8", "Chromium";v="138", "Google Chrome";v="138"',
+            "sec-ch-ua-mobile": "?0",
             "Content-Type": "application/json",
             "Accept": "application/json, text/plain, */*",
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
-            "X-APP-VERSION": "2.3.0",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36",
+            "X-APP-VERSION": "2.4.2",
             "Origin": self.BASE_URL,
             "Referer": f"{self.BASE_URL}/chat?_userMenuKey=chat",
             "Sec-Fetch-Site": "same-origin",
             "Sec-Fetch-Mode": "cors",
             "Sec-Fetch-Dest": "empty",
+            "Accept-Language": "zh-CN,zh;q=0.9",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Connection": "keep-alive",
         }
 
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
-        if self.model_name not in self.get_available_models():
-            PrettyOutput.print(
-                f"警告: 选择的模型 {self.model_name} 不在可用列表中", OutputType.WARNING
-            )
 
     def set_model_name(self, model_name: str):
         """Set model name"""
@@ -60,7 +62,14 @@ class AI8Model(BasePlatform):
             # 1. 创建会话
             response = while_success(
                 lambda: http.post(
-                    f"{self.BASE_URL}/api/chat/session", headers=self.headers, json={}
+                    f"{self.BASE_URL}/api/chat/session",
+                    headers=self.headers,
+                    json={
+                        "mcp": [],
+                        "model": self.model_name,
+                        "plugins": [],
+                        "rags": [],
+                    },
                 ),
                 sleep_time=5,
             )
@@ -83,6 +92,7 @@ class AI8Model(BasePlatform):
                 "plugins": [],
                 "localPlugins": None,
                 "useAppId": 0,
+                "temperature": 0,
             }
 
             response = while_success(
@@ -127,33 +137,30 @@ class AI8Model(BasePlatform):
                 "files": [],
             }
 
+            # 为流式请求构造专用的请求头，避免 'Accept' 和 'accept' 键冲突
+            stream_headers = self.headers.copy()
+            stream_headers["Accept"] = "text/event-stream"  # 添加流式专用的accept头
+
             # 使用stream_post进行流式请求
             response_stream = while_success(
                 lambda: http.stream_post(
                     f"{self.BASE_URL}/api/chat/completions",
-                    headers=self.headers,
+                    headers=stream_headers,
                     json=payload,
                 ),
                 sleep_time=5,
             )
 
             # 处理流式响应
-            for chunk in response_stream:
-                if chunk:
+            for line in response_stream:
+                if line and line.startswith("data: "):
                     try:
-                        line = chunk.decode("utf-8")
-                        if line.startswith("data: "):
-                            try:
-                                data = json.loads(line[6:])
-                                if data.get("type") == "string":
-                                    chunk_data = data.get("data", "")
-                                    if chunk_data:
-                                        yield chunk_data
-
-                            except json.JSONDecodeError:
-                                continue
-
-                    except UnicodeDecodeError:
+                        data = json.loads(line[6:])
+                        if data.get("type") == "string":
+                            chunk_data = data.get("data", "")
+                            if chunk_data:
+                                yield chunk_data
+                    except json.JSONDecodeError:
                         continue
 
             return None
@@ -313,3 +320,13 @@ class AI8Model(BasePlatform):
 
     def upload_files(self, file_list: List[str]) -> bool:
         return False
+
+    @classmethod
+    def get_required_env_keys(cls) -> List[str]:
+        """
+        获取AI8平台所需的环境变量键列表
+
+        返回:
+            List[str]: 环境变量键的列表
+        """
+        return ["AI8_API_KEY"]

jarvis/jarvis_platform/base.py

@@ -1,20 +1,30 @@
 # -*- coding: utf-8 -*-
 import re
+import os
+from datetime import datetime
 from abc import ABC, abstractmethod
-from typing import Generator, List, Tuple
+from types import TracebackType
+from typing import Dict, Generator, List, Optional, Tuple, Type
+
+from typing_extensions import Self
 
 from rich import box  # type: ignore
 from rich.live import Live  # type: ignore
 from rich.panel import Panel  # type: ignore
+from rich.status import Status  # type: ignore
 from rich.text import Text  # type: ignore
 
 from jarvis.jarvis_utils.config import (
     get_max_input_token_count,
     get_pretty_output,
     is_print_prompt,
+    is_immediate_abort,
+    is_save_session_history,
+    get_data_dir,
 )
 from jarvis.jarvis_utils.embedding import split_text_into_chunks
-from jarvis.jarvis_utils.globals import set_in_chat
+from jarvis.jarvis_utils.globals import set_in_chat, get_interrupt, console
+import jarvis.jarvis_utils.globals as G
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
 from jarvis.jarvis_utils.utils import get_context_token_count, while_success, while_true
@@ -28,9 +38,20 @@ class BasePlatform(ABC):
         self.suppress_output = True  # 添加输出控制标志
         self.web = False  # 添加web属性，默认false
         self._saved = False
-
-    def __del__(self):
-        """Destroy model"""
+        self.model_group: Optional[str] = None
+        self._session_history_file: Optional[str] = None
+
+    def __enter__(self) -> Self:
+        """Enter context manager"""
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        """Exit context manager"""
         if not self._saved:
             self.delete_chat()
 
@@ -42,6 +63,7 @@ class BasePlatform(ABC):
     def reset(self):
         """Reset model"""
         self.delete_chat()
+        self._session_history_file = None
 
     @abstractmethod
     def chat(self, message: str) -> Generator[str, None, None]:
@@ -62,31 +84,37 @@ class BasePlatform(ABC):
 
         start_time = time.time()
 
+        # 当输入为空白字符串时，打印警告并直接返回空字符串
+        if message.strip() == "":
+            PrettyOutput.print("输入为空白字符串，已忽略本次请求", OutputType.WARNING)
+            return ""
+
         input_token_count = get_context_token_count(message)
 
-        if input_token_count > get_max_input_token_count():
-            max_chunk_size = get_max_input_token_count() - 1024  # 留出一些余量
-            min_chunk_size = get_max_input_token_count() - 2048
+        if input_token_count > get_max_input_token_count(self.model_group):
+            max_chunk_size = (
+                get_max_input_token_count(self.model_group) - 1024
+            )  # 留出一些余量
+            min_chunk_size = get_max_input_token_count(self.model_group) - 2048
             inputs = split_text_into_chunks(message, max_chunk_size, min_chunk_size)
-            print("📤 正在提交长上下文...")
-            prefix_prompt = f"""
+            PrettyOutput.print(
+                f"长上下文，分批提交，共{len(inputs)}部分...", OutputType.INFO
+            )
+            prefix_prompt = """
             我将分多次提供大量内容，在我明确告诉你内容已经全部提供完毕之前，每次仅需要输出"已收到"，明白请输出"开始接收输入"。
             """
-            while_true(lambda: while_success(lambda: self.chat(prefix_prompt), 5), 5)
+            while_true(lambda: while_success(lambda: self._chat(prefix_prompt), 5), 5)
             submit_count = 0
             length = 0
             response = ""
             for input in inputs:
                 submit_count += 1
                 length += len(input)
-                print(
-                    f"📤 正在提交第{submit_count}部分（共{len(inputs)}部分({length}/{len(message)})）"
-                )
 
                 response += "\n"
                 for trunk in while_true(
                     lambda: while_success(
-                        lambda: self.chat(
+                        lambda: self._chat(
                             f"<part_content>{input}</part_content>\n\n请返回<已收到>，不需要返回其他任何内容"
                         ),
                         5,
@@ -95,10 +123,7 @@ class BasePlatform(ABC):
                 ):
                     response += trunk
 
-                print(
-                    f"📤 提交第{submit_count}部分完成，当前进度：{length}/{len(message)}"
-                )
-            print("✅ 提交完成")
+            PrettyOutput.print("提交完成", OutputType.SUCCESS)
             response += "\n" + while_true(
                 lambda: while_success(
                     lambda: self._chat("内容已经全部提供完毕，请根据内容继续"), 5
@@ -108,48 +133,112 @@ class BasePlatform(ABC):
         else:
             response = ""
 
-            text_content = Text()
-            panel = Panel(
-                text_content,
-                title=f"[bold cyan]{self.name()}[/bold cyan]",
-                subtitle="[dim]思考中...[/dim]",
-                border_style="bright_blue",
-                box=box.ROUNDED,
-            )
-
             if not self.suppress_output:
                 if get_pretty_output():
-                    with Live(panel, refresh_per_second=10, transient=False) as live:
-                        for s in self.chat(message):
-                            response += s
-                            text_content.append(s, style="bright_white")
-                            panel.subtitle = "[yellow]正在回答...[/yellow]"
-                            live.update(panel)
-                        end_time = time.time()
-                        duration = end_time - start_time
-                        char_count = len(response)
-                        # Calculate token count and tokens per second
+                    chat_iterator = self.chat(message)
+                    first_chunk = None
+
+                    with Status(
+                        f"🤔 {(G.current_agent_name + ' · ') if G.current_agent_name else ''}{self.name()} 正在思考中...",
+                        spinner="dots",
+                        console=console,
+                    ):
                         try:
-                            token_count = get_context_token_count(response)
-                            tokens_per_second = (
-                                token_count / duration if duration > 0 else 0
+                            while True:
+                                first_chunk = next(chat_iterator)
+                                if first_chunk:
+                                    break
+                        except StopIteration:
+                            self._append_session_history(message, "")
+                            return ""
+
+                    text_content = Text(overflow="fold")
+                    panel = Panel(
+                        text_content,
+                        title=f"[bold cyan]{(G.current_agent_name + ' · ') if G.current_agent_name else ''}{self.name()}[/bold cyan]",
+                        subtitle="[yellow]正在回答... (按 Ctrl+C 中断)[/yellow]",
+                        border_style="bright_blue",
+                        box=box.ROUNDED,
+                        expand=True,  # 允许面板自动调整大小
+                    )
+
+                    with Live(panel, refresh_per_second=4, transient=False) as live:
+
+                        def _update_panel_content(content: str):
+                            text_content.append(content, style="bright_white")
+                            # --- Scrolling Logic ---
+                            # Calculate available height in the panel
+                            max_text_height = (
+                                console.height - 5
+                            )  # Leave space for borders/titles
+                            if max_text_height <= 0:
+                                max_text_height = 1
+
+                            # Get the actual number of lines the text will wrap to
+                            lines = text_content.wrap(
+                                console,
+                                console.width - 4 if console.width > 4 else 1,
                             )
-                        except Exception as e:
-                            PrettyOutput.print(
-                                f"Tokenization failed: {str(e)}", OutputType.WARNING
+
+                            # If content overflows, truncate to show only the last few lines
+                            if len(lines) > max_text_height:
+                                # Rebuild the text from the wrapped lines to ensure visual consistency
+                                # This correctly handles both wrapped long lines and explicit newlines
+                                text_content.plain = "\n".join(
+                                    [line.plain for line in lines[-max_text_height:]]
+                                )
+
+                            panel.subtitle = (
+                                "[yellow]正在回答... (按 Ctrl+C 中断)[/yellow]"
                             )
-                            token_count = 0
-                            tokens_per_second = 0
-                        panel.subtitle = f"[bold green]✓ 对话完成耗时: {duration:.2f}秒, 输入字符数: {len(message)}, 输入Token数量: {input_token_count}, 输出字符数: {char_count}, 输出Token数量: {token_count}, 每秒Token数量: {tokens_per_second:.2f}[/bold green]"
+                            live.update(panel)
+
+                        # Process first chunk
+                        response += first_chunk
+                        if first_chunk:
+                            _update_panel_content(first_chunk)
+
+                        # Process rest of the chunks
+                        for s in chat_iterator:
+                            if not s:
+                                continue
+                            response += s  # Accumulate the full response string
+                            _update_panel_content(s)
+
+                            if is_immediate_abort() and get_interrupt():
+                                self._append_session_history(message, response)
+                                return response  # Return the partial response immediately
+
+                        # At the end, display the entire response
+                        text_content.plain = response
+
+                        end_time = time.time()
+                        duration = end_time - start_time
+                        panel.subtitle = f"[bold green]✓ 对话完成耗时: {duration:.2f}秒[/bold green]"
                         live.update(panel)
+                    console.print()
                 else:
+                    # Print a clear prefix line before streaming model output (non-pretty mode)
+                    console.print(
+                        f"🤖 模型输出 - {(G.current_agent_name + ' · ') if G.current_agent_name else ''}{self.name()}  (按 Ctrl+C 中断)",
+                        soft_wrap=False,
+                    )
                     for s in self.chat(message):
-                        print(s, end="", flush=True)
+                        console.print(s, end="")
                         response += s
-                    print()
+                        if is_immediate_abort() and get_interrupt():
+                            self._append_session_history(message, response)
+                            return response
+                    console.print()
+                    end_time = time.time()
+                    duration = end_time - start_time
+                    console.print(f"✓ 对话完成耗时: {duration:.2f}秒")
             else:
                 for s in self.chat(message):
                     response += s
+                    if is_immediate_abort() and get_interrupt():
+                        self._append_session_history(message, response)
+                        return response
         # Keep original think tag handling
         response = re.sub(
             ot("think") + r".*?" + ct("think"), "", response, flags=re.DOTALL
@@ -157,6 +246,8 @@ class BasePlatform(ABC):
         response = re.sub(
             ot("thinking") + r".*?" + ct("thinking"), "", response, flags=re.DOTALL
         )
+        # Save session history (input and full response)
+        self._append_session_history(message, response)
         return response
 
     def chat_until_success(self, message: str) -> str:
@@ -229,14 +320,84 @@ class BasePlatform(ABC):
         """Get model list"""
         raise NotImplementedError("get_model_list is not implemented")
 
+    @classmethod
+    @abstractmethod
+    def get_required_env_keys(cls) -> List[str]:
+        """Get required env keys"""
+        raise NotImplementedError("get_required_env_keys is not implemented")
+
+    @classmethod
+    def get_env_defaults(cls) -> Dict[str, str]:
+        """Get env default values"""
+        return {}
+
+    @classmethod
+    def get_env_config_guide(cls) -> Dict[str, str]:
+        """Get environment variable configuration guide
+
+        Returns:
+            Dict[str, str]: A dictionary mapping env key names to their configuration instructions
+        """
+        return {}
+
     def set_suppress_output(self, suppress: bool):
         """Set whether to suppress output"""
         self.suppress_output = suppress
 
+    def set_model_group(self, model_group: Optional[str]):
+        """Set model group"""
+        self.model_group = model_group
+
     def set_web(self, web: bool):
         """Set web flag"""
         self.web = web
 
+    def _append_session_history(self, user_input: str, model_output: str) -> None:
+        """
+        Append the user input and model output to a session history file if enabled.
+        The file name is generated on first save and reused until reset.
+        """
+        try:
+            if not is_save_session_history():
+                return
+
+            if self._session_history_file is None:
+                # Ensure session history directory exists under data directory
+                data_dir = get_data_dir()
+                session_dir = os.path.join(data_dir, "session_history")
+                os.makedirs(session_dir, exist_ok=True)
+
+                # Build a safe filename including platform, model and timestamp
+                try:
+                    platform_name = type(self).platform_name()
+                except Exception:
+                    platform_name = "unknown_platform"
+
+                try:
+                    model_name = self.name()
+                except Exception:
+                    model_name = "unknown_model"
+
+                safe_platform = re.sub(r"[^\w\-\.]+", "_", str(platform_name))
+                safe_model = re.sub(r"[^\w\-\.]+", "_", str(model_name))
+                ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+                self._session_history_file = os.path.join(
+                    session_dir, f"session_history_{safe_platform}_{safe_model}_{ts}.log"
+                )
+
+            # Append record
+            with open(self._session_history_file, "a", encoding="utf-8", errors="ignore") as f:
+                ts_line = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                f.write(f"===== {ts_line} =====\n")
+                f.write("USER:\n")
+                f.write(f"{user_input}\n")
+                f.write("\nASSISTANT:\n")
+                f.write(f"{model_output}\n\n")
+        except Exception:
+            # Do not break chat flow if writing history fails
+            pass
+
     @abstractmethod
     def support_web(self) -> bool:
         """Check if platform supports web functionality"""

jarvis/jarvis_platform/human.py

@@ -10,9 +10,9 @@ import string
 from typing import Generator, List, Tuple
 
 from jarvis.jarvis_platform.base import BasePlatform
+from jarvis.jarvis_utils.clipboard import copy_to_clipboard
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.utils import copy_to_clipboard
 
 
 class HumanPlatform(BasePlatform):
@@ -131,3 +131,13 @@ class HumanPlatform(BasePlatform):
     def support_upload_files(self) -> bool:
         """是否支持文件上传功能"""
         return False
+
+    @classmethod
+    def get_required_env_keys(cls) -> List[str]:
+        """
+        获取Human平台所需的环境变量键列表
+
+        返回:
+            List[str]: 环境变量键的列表
+        """
+        return []