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

jarvis/jarvis_platform/kimi.py

@@ -24,8 +24,8 @@ class KimiModel(BasePlatform):
     def get_model_list(self) -> List[Tuple[str, str]]:
         """Get model list"""
         return [
-            ("kimi", "基于网页的 Kimi，免费接口"),
-            ("k1", "基于网页的 Kimi，深度思考模型"),
+            ("k1.5", "基于网页的 Kimi，免费接口"),
+            ("k1.5-thinking", "基于网页的 Kimi，深度思考模型"),
             ("k2", "基于网页的 Kimi，深度思考模型 K2"),
         ]
 
@@ -156,39 +156,24 @@ class KimiModel(BasePlatform):
                 sleep_time=5,
             )
 
-            response_data = b""
-
             # 处理流式响应
-            for chunk in response_stream:
-                response_data += chunk
-
-                # 尝试解析SSE格式的数据
-                try:
-                    # 查找完整的数据行
-                    lines = response_data.decode("utf-8").split("\n")
-                    response_data = b""  # 重置缓冲区
-
-                    for line in lines:
-                        if not line.strip():
-                            continue
-
-                        # SSE格式的行通常以"data: "开头
-                        if line.startswith("data: "):
-                            try:
-                                data = json.loads(line[6:])
-                                if data.get("event") == "resp":
-                                    status = data.get("file_info", {}).get("status")
-                                    if status == "parsed":
-                                        return True
-                                    elif status == "failed":
-                                        return False
-                            except json.JSONDecodeError:
-                                continue
-
-                except UnicodeDecodeError:
-                    # 如果解码失败，继续累积数据
+            for line in response_stream:
+                if not line.strip():
                     continue
 
+                # SSE格式的行通常以"data: "开头
+                if line.startswith("data: "):
+                    try:
+                        data = json.loads(line[6:])
+                        if data.get("event") == "resp":
+                            status = data.get("file_info", {}).get("status")
+                            if status == "parsed":
+                                return True
+                            elif status == "failed":
+                                return False
+                    except json.JSONDecodeError:
+                        continue
+
             retry_count += 1
             time.sleep(1)
 
@@ -200,16 +185,16 @@ class KimiModel(BasePlatform):
             return True
 
         if not self.chat_id:
-            print("🚀 正在创建聊天会话...")
+            PrettyOutput.print("正在创建聊天会话...", OutputType.INFO)
             if not self._create_chat():
-                print("❌ 创建聊天会话失败")
+                PrettyOutput.print("创建聊天会话失败", OutputType.ERROR)
                 return False
-            print("✅ 创建聊天会话成功")
+            PrettyOutput.print("创建聊天会话成功", OutputType.SUCCESS)
 
         uploaded_files = []
         for index, file_path in enumerate(file_list, 1):
             file_name = os.path.basename(file_path)
-            print(f"🔍 处理文件 [{index}/{len(file_list)}]: {file_name}")
+            log_lines: List[str] = [f"处理文件 [{index}/{len(file_list)}]: {file_name}"]
             try:
                 mime_type, _ = mimetypes.guess_type(file_path)
                 action = (
@@ -217,34 +202,40 @@ class KimiModel(BasePlatform):
                 )
 
                 # 获取预签名URL
-                print(f"🔍 获取上传URL: {file_name}")
+                log_lines.append(f"获取上传URL: {file_name}")
                 presigned_data = self._get_presigned_url(file_path, action)
 
                 # 上传文件
-                print(f"🔍 上传文件: {file_name}")
+                log_lines.append(f"上传文件: {file_name}")
                 if self._upload_file(file_path, presigned_data["url"]):
                     # 获取文件信息
-                    print(f"🔍 获取文件信息: {file_name}")
+                    log_lines.append(f"获取文件信息: {file_name}")
                     file_info = self._get_file_info(presigned_data, file_name, action)
 
                     # 只有文件需要解析
                     if action == "file":
-                        print(f"🔍 等待文件解析: {file_name}")
+                        log_lines.append(f"等待文件解析: {file_name}")
                         if self._wait_for_parse(file_info["id"]):
                             uploaded_files.append(file_info)
-                            print(f"✅ 文件处理完成: {file_name}")
+                            log_lines.append(f"文件处理完成: {file_name}")
                         else:
-                            print(f"❌ 文件解析失败: {file_name}")
+                            log_lines.append(f"文件解析失败: {file_name}")
+                            PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                             return False
                     else:
                         uploaded_files.append(file_info)
-                        print(f"✅ 图片处理完成: {file_name}")
+                        log_lines.append(f"图片处理完成: {file_name}")
                 else:
-                    print(f"❌ 文件上传失败: {file_name}")
+                    log_lines.append(f"文件上传失败: {file_name}")
+                    PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                     return False
 
+                # 成功路径统一输出本文件的处理日志
+                PrettyOutput.print("\n".join(log_lines), OutputType.INFO)
+
             except Exception as e:
-                print(f"❌ 处理文件出错 {file_path}: {str(e)}")
+                log_lines.append(f"处理文件出错 {file_path}: {str(e)}")
+                PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                 return False
 
         self.uploaded_files = uploaded_files
@@ -299,40 +290,25 @@ class KimiModel(BasePlatform):
                 sleep_time=5,
             )
 
-            response_data = b""
-
             # 处理流式响应
-            for chunk in response_stream:
-                response_data += chunk
-
-                # 尝试解析SSE格式的数据
-                try:
-                    # 查找完整的数据行
-                    lines = response_data.decode("utf-8").split("\n")
-                    response_data = b""  # 重置缓冲区
-
-                    for line in lines:
-                        if not line.strip():
-                            continue
-
-                        # SSE格式的行通常以"data: "开头
-                        if line.startswith("data: "):
-                            try:
-                                data = json.loads(line[6:])
-                                event = data.get("event")
-
-                                if event == "cmpl":
-                                    # 处理补全文本
-                                    text = data.get("text", "")
-                                    if text:
-                                        yield text
-                            except json.JSONDecodeError:
-                                continue
-
-                except UnicodeDecodeError:
-                    # 如果解码失败，继续累积数据
+            for line in response_stream:
+                if not line.strip():
                     continue
 
+                # SSE格式的行通常以"data: "开头
+                if line.startswith("data: "):
+                    try:
+                        data = json.loads(line[6:])
+                        event = data.get("event")
+
+                        if event == "cmpl":
+                            # 处理补全文本
+                            text = data.get("text", "")
+                            if text:
+                                yield text
+                    except json.JSONDecodeError:
+                        continue
+
             return None
 
         except Exception as e:
@@ -425,3 +401,33 @@ class KimiModel(BasePlatform):
     def support_web(self) -> bool:
         """Kimi平台支持web功能"""
         return True
+
+    @classmethod
+    def get_required_env_keys(cls) -> List[str]:
+        """
+        获取Kimi平台所需的环境变量键列表
+
+        返回:
+            List[str]: 环境变量键的列表
+        """
+        return ["KIMI_API_KEY"]
+
+    @classmethod
+    def get_env_config_guide(cls) -> Dict[str, str]:
+        """
+        获取环境变量配置指导
+
+        返回:
+            Dict[str, str]: 环境变量名到配置指导的映射
+        """
+        return {
+            "KIMI_API_KEY": (
+                "1. 登录 Kimi 网页版: https://kimi.moonshot.cn/\n"
+                "2. 打开浏览器开发者工具 (F12)\n"
+                '3. 切换到"网络"(Network)标签页\n'
+                "4. 在 Kimi 中发送一条消息\n"
+                "5. 找到 stream 请求\n"
+                '6. 在"请求标头"中找到 authorization 字段\n'
+                "7. 复制 Bearer 后面的 API Key 部分"
+            )
+        }

jarvis/jarvis_platform/openai.py

@@ -24,7 +24,32 @@ class OpenAIModel(BasePlatform):
         self.base_url = os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1")
         self.model_name = os.getenv("JARVIS_MODEL") or "gpt-4o"
 
-        self.client = OpenAI(api_key=self.api_key, base_url=self.base_url)
+                # Optional: Inject extra HTTP headers via environment variable
+        # Expected format: OPENAI_EXTRA_HEADERS='{"Header-Name": "value", "X-Trace": "abc"}'
+        headers_str = os.getenv("OPENAI_EXTRA_HEADERS")
+        self.extra_headers: Dict[str, str] = {}
+        if headers_str:
+            try:
+                parsed = json.loads(headers_str)
+                if isinstance(parsed, dict):
+                    # Ensure all header keys/values are strings
+                    self.extra_headers = {str(k): str(v) for k, v in parsed.items()}
+                else:
+                    PrettyOutput.print("OPENAI_EXTRA_HEADERS 应为 JSON 对象，如 {'X-Source':'jarvis'}", OutputType.WARNING)
+            except Exception as e:
+                PrettyOutput.print(f"解析 OPENAI_EXTRA_HEADERS 失败: {e}", OutputType.WARNING)
+
+        # Initialize OpenAI client, try to pass default headers if SDK supports it
+        try:
+            if self.extra_headers:
+                self.client = OpenAI(api_key=self.api_key, base_url=self.base_url, default_headers=self.extra_headers)
+            else:
+                self.client = OpenAI(api_key=self.api_key, base_url=self.base_url)
+        except TypeError:
+            # Fallback: SDK version may not support default_headers
+            self.client = OpenAI(api_key=self.api_key, base_url=self.base_url)
+            if self.extra_headers:
+                PrettyOutput.print("当前 OpenAI SDK 不支持 default_headers，未能注入额外 HTTP 头", OutputType.WARNING)
         self.messages: List[Dict[str, str]] = []
         self.system_message = ""
 
@@ -211,3 +236,50 @@ class OpenAIModel(BasePlatform):
             bool: 当前是否支持上传文件 (OpenAI平台始终返回False)
         """
         return False
+
+    @classmethod
+    def get_required_env_keys(cls) -> List[str]:
+        """
+        获取OpenAI平台所需的环境变量键列表
+
+        返回:
+            List[str]: 环境变量键的列表
+        """
+        return ["OPENAI_API_KEY", "OPENAI_API_BASE"]
+
+    @classmethod
+    def get_env_config_guide(cls) -> Dict[str, str]:
+        """
+        获取环境变量配置指导
+
+        返回:
+            Dict[str, str]: 环境变量名到配置指导的映射
+        """
+        return {
+            "OPENAI_API_KEY": (
+                "请输入您的 OpenAI API Key:\n"
+                "获取方式一（官方）:\n"
+                "1. 登录 OpenAI 平台: https://platform.openai.com/\n"
+                "2. 进入 API Keys 页面\n"
+                "3. 创建新的 API Key 或使用现有的\n"
+                "4. 复制 API Key (以 sk- 开头)\n"
+                "\n获取方式二（第三方代理）:\n"
+                "如果使用第三方代理服务，请从代理服务商处获取 API Key"
+            ),
+            "OPENAI_API_BASE": (
+                "请输入 API Base URL:\n"
+                "- 官方 API: https://api.openai.com/v1\n"
+                "- 如使用代理或第三方服务，请输入对应的 Base URL\n"
+                "- 例如: https://your-proxy.com/v1"
+            ),
+        }
+
+    @classmethod
+    def get_env_defaults(cls) -> Dict[str, str]:
+        """
+        获取OpenAI平台环境变量的默认值
+
+        返回:
+            Dict[str, str]: 环境变量默认值的字典
+        """
+        return {"OPENAI_API_BASE": "https://api.openai.com/v1"}

jarvis/jarvis_platform/registry.py

@@ -10,8 +10,6 @@ from jarvis.jarvis_utils.config import (
     get_data_dir,
     get_normal_model_name,
     get_normal_platform_name,
-    get_thinking_model_name,
-    get_thinking_platform_name,
 )
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
@@ -41,7 +39,7 @@ class PlatformRegistry:
                 # 创建 __init__.py 使其成为 Python 包
                 with open(
                     os.path.join(user_platform_dir, "__init__.py"), "w", errors="ignore"
-                ) as f:
+                ):
                     pass
             except Exception as e:
                 PrettyOutput.print(f"创建平台目录失败: {str(e)}", OutputType.ERROR)
@@ -113,6 +111,7 @@ class PlatformRegistry:
         if directory not in sys.path:
             sys.path.append(directory)
 
+        error_lines = []
         # 遍历目录下的所有.py文件
         for filename in os.listdir(directory):
             if filename.endswith(".py") and not filename.startswith("__"):
@@ -142,16 +141,15 @@ class PlatformRegistry:
                                 platform_name = obj.platform_name()
                                 platforms[platform_name] = obj
                             except Exception as e:
-                                PrettyOutput.print(
-                                    f"实例化或注册平台失败 {obj.__name__}: {str(e)}",
-                                    OutputType.ERROR,
+                                error_lines.append(
+                                    f"实例化或注册平台失败 {obj.__name__}: {str(e)}"
                                 )
                             break
                 except Exception as e:
-                    PrettyOutput.print(
-                        f"加载平台 {module_name} 失败: {str(e)}", OutputType.ERROR
-                    )
+                    error_lines.append(f"加载平台 {module_name} 失败: {str(e)}")
 
+        if error_lines:
+            PrettyOutput.print("\n".join(error_lines), OutputType.ERROR)
         return platforms
 
     @staticmethod
@@ -187,12 +185,7 @@ class PlatformRegistry:
         platform.set_model_name(model_name)  # type: ignore
         return platform  # type: ignore
 
-    def get_thinking_platform(self) -> BasePlatform:
-        platform_name = get_thinking_platform_name()
-        model_name = get_thinking_model_name()
-        platform = self.create_platform(platform_name)
-        platform.set_model_name(model_name)  # type: ignore
-        return platform  # type: ignore
+
 
     def register_platform(self, name: str, platform_class: Type[BasePlatform]) -> None:
         """Register platform class