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

jarvis/jarvis_platform/human.py

@@ -12,7 +12,6 @@ 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
 
 
 class HumanPlatform(BasePlatform):
@@ -39,7 +38,7 @@ class HumanPlatform(BasePlatform):
         if model_name == "human":
             self.model_name = model_name
         else:
-            PrettyOutput.print(f"错误：不支持的模型: {model_name}", OutputType.ERROR)
+            print(f"❌ 错误：不支持的模型: {model_name}")
 
     def chat(self, message: str) -> Generator[str, None, None]:
         """发送消息并获取人类响应"""
@@ -66,7 +65,7 @@ class HumanPlatform(BasePlatform):
 
     def upload_files(self, file_list: List[str]) -> bool:
         """文件上传功能，人类平台不需要实际处理"""
-        PrettyOutput.print("人类交互平台不支持文件上传", OutputType.WARNING)
+        print("⚠️ 人类交互平台不支持文件上传")
         return False
 
     def delete_chat(self) -> bool:
@@ -88,10 +87,10 @@ class HumanPlatform(BasePlatform):
             with open(file_path, "w", encoding="utf-8") as f:
                 json.dump(state, f, ensure_ascii=False, indent=4)
             self._saved = True
-            PrettyOutput.print(f"会话已成功保存到 {file_path}", OutputType.SUCCESS)
+            print(f"✅ 会话已成功保存到 {file_path}")
             return True
         except Exception as e:
-            PrettyOutput.print(f"保存会话失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 保存会话失败: {str(e)}")
             return False
 
     def restore(self, file_path: str) -> bool:
@@ -106,13 +105,13 @@ class HumanPlatform(BasePlatform):
             self.first_message = state.get("first_message", True)
             self._saved = True
 
-            PrettyOutput.print(f"从 {file_path} 成功恢复会话", OutputType.SUCCESS)
+            print(f"✅ 从 {file_path} 成功恢复会话")
             return True
         except FileNotFoundError:
-            PrettyOutput.print(f"会话文件未找到: {file_path}", OutputType.ERROR)
+            print(f"❌ 会话文件未找到: {file_path}")
             return False
         except Exception as e:
-            PrettyOutput.print(f"恢复会话失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 恢复会话失败: {str(e)}")
             return False
 
     def name(self) -> str:

jarvis/jarvis_platform/kimi.py

@@ -9,7 +9,6 @@ from typing import Dict, Generator, List, Tuple
 
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_utils import http
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import while_success
 
 
@@ -37,7 +36,7 @@ class KimiModel(BasePlatform):
         self.chat_id = ""  # 当前会话ID
         self.api_key = os.getenv("KIMI_API_KEY")  # 从环境变量获取API密钥
         if not self.api_key:
-            PrettyOutput.print("KIMI_API_KEY 未设置", OutputType.WARNING)
+            print("⚠️ KIMI_API_KEY 未设置")
         self.auth_header = f"Bearer {self.api_key}"  # 认证头信息
         self.uploaded_files = []  # 存储已上传文件的信息
         self.chat_id = ""  # 当前会话ID
@@ -65,18 +64,15 @@ class KimiModel(BasePlatform):
         }
         try:
             response = while_success(
-                lambda: http.post(url, headers=headers, data=payload),
-                sleep_time=5,
+                lambda: http.post(url, headers=headers, data=payload)
             )
             if response.status_code != 200:
-                PrettyOutput.print(
-                    f"错误：创建会话失败：{response.json()}", OutputType.ERROR
-                )
+                print(f"❌ 错误：创建会话失败：{response.json()}")
                 return False
             self.chat_id = response.json()["id"]
             return True
         except Exception as e:
-            PrettyOutput.print(f"错误：创建会话失败：{e}", OutputType.ERROR)
+            print(f"❌ 错误：创建会话失败：{e}")
             return False
 
     def _get_presigned_url(self, filename: str, action: str) -> Dict:
@@ -93,8 +89,7 @@ class KimiModel(BasePlatform):
         }
 
         response = while_success(
-            lambda: http.post(url, headers=headers, data=payload), sleep_time=5
-        )
+            lambda: http.post(url, headers=headers, data=payload)        )
         return response.json()
 
     def support_upload_files(self) -> bool:
@@ -107,11 +102,11 @@ class KimiModel(BasePlatform):
             with open(file_path, "rb") as f:
                 content = f.read()
                 response = while_success(
-                    lambda: http.put(presigned_url, data=content), sleep_time=5
+                    lambda: http.put(presigned_url, data=content)
                 )
                 return response.status_code == 200
         except Exception as e:
-            PrettyOutput.print(f"错误：上传文件失败：{e}", OutputType.ERROR)
+            print(f"❌ 错误：上传文件失败：{e}")
             return False
 
     def _get_file_info(self, file_data: Dict, name: str, file_type: str) -> Dict:
@@ -134,8 +129,7 @@ class KimiModel(BasePlatform):
         }
 
         response = while_success(
-            lambda: http.post(url, headers=headers, data=payload), sleep_time=5
-        )
+            lambda: http.post(url, headers=headers, data=payload)        )
         return response.json()
 
     def _wait_for_parse(self, file_id: str) -> bool:
@@ -153,7 +147,6 @@ class KimiModel(BasePlatform):
             payload = {"ids": [file_id]}
             response_stream = while_success(
                 lambda: http.stream_post(url, headers=headers, json=payload),
-                sleep_time=5,
             )
 
             # 处理流式响应
@@ -171,7 +164,7 @@ class KimiModel(BasePlatform):
                                 return True
                             elif status == "failed":
                                 return False
-                    except json.JSONDecodeError:
+                    except Exception:
                         continue
 
             retry_count += 1
@@ -185,11 +178,11 @@ class KimiModel(BasePlatform):
             return True
 
         if not self.chat_id:
-            PrettyOutput.print("正在创建聊天会话...", OutputType.INFO)
+            print("ℹ️ 正在创建聊天会话...")
             if not self._create_chat():
-                PrettyOutput.print("创建聊天会话失败", OutputType.ERROR)
+                print("❌ 创建聊天会话失败")
                 return False
-            PrettyOutput.print("创建聊天会话成功", OutputType.SUCCESS)
+            print("✅ 创建聊天会话成功")
 
         uploaded_files = []
         for index, file_path in enumerate(file_list, 1):
@@ -220,22 +213,26 @@ class KimiModel(BasePlatform):
                             log_lines.append(f"文件处理完成: {file_name}")
                         else:
                             log_lines.append(f"文件解析失败: {file_name}")
-                            PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
+                            joined_logs = '\n'.join(log_lines)
+                            print(f"❌ {joined_logs}")
                             return False
                     else:
                         uploaded_files.append(file_info)
                         log_lines.append(f"图片处理完成: {file_name}")
                 else:
                     log_lines.append(f"文件上传失败: {file_name}")
-                    PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
+                    joined_logs = '\n'.join(log_lines)
+                    print(f"❌ {joined_logs}")
                     return False
 
                 # 成功路径统一输出本文件的处理日志
-                PrettyOutput.print("\n".join(log_lines), OutputType.INFO)
+                joined_logs = '\n'.join(log_lines)
+                print(f"ℹ️ {joined_logs}")
 
             except Exception as e:
                 log_lines.append(f"处理文件出错 {file_path}: {str(e)}")
-                PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
+                joined_logs = '\n'.join(log_lines)
+                print(f"❌ {joined_logs}")
                 return False
 
         self.uploaded_files = uploaded_files
@@ -287,7 +284,6 @@ class KimiModel(BasePlatform):
             # 使用新的stream_post接口发送消息请求，获取流式响应
             response_stream = while_success(
                 lambda: http.stream_post(url, headers=headers, json=payload),
-                sleep_time=5,
             )
 
             # 处理流式响应
@@ -306,7 +302,7 @@ class KimiModel(BasePlatform):
                             text = data.get("text", "")
                             if text:
                                 yield text
-                    except json.JSONDecodeError:
+                    except Exception:
                         continue
 
             return None
@@ -327,7 +323,7 @@ class KimiModel(BasePlatform):
 
         try:
             response = while_success(
-                lambda: http.delete(url, headers=headers), sleep_time=5
+                lambda: http.delete(url, headers=headers)
             )
             if response.status_code == 200:
                 self.chat_id = ""
@@ -335,18 +331,16 @@ class KimiModel(BasePlatform):
                 self.first_chat = True  # 重置first_chat标记
                 return True
             else:
-                PrettyOutput.print(
-                    f"删除会话失败: HTTP {response.status_code}", OutputType.WARNING
-                )
+                print(f"⚠️ 删除会话失败: HTTP {response.status_code}")
                 return False
         except Exception as e:
-            PrettyOutput.print(f"删除会话时发生错误: {str(e)}", OutputType.ERROR)
+            print(f"❌ 删除会话时发生错误: {str(e)}")
             return False
 
     def save(self, file_path: str) -> bool:
         """Save chat session to a file."""
         if not self.chat_id:
-            PrettyOutput.print("没有活动的会话可供保存", OutputType.WARNING)
+            print("⚠️ 没有活动的会话可供保存")
             return False
 
         state = {
@@ -361,10 +355,10 @@ class KimiModel(BasePlatform):
             with open(file_path, "w", encoding="utf-8") as f:
                 json.dump(state, f, ensure_ascii=False, indent=4)
             self._saved = True
-            PrettyOutput.print(f"会话已成功保存到 {file_path}", OutputType.SUCCESS)
+            print(f"✅ 会话已成功保存到 {file_path}")
             return True
         except Exception as e:
-            PrettyOutput.print(f"保存会话失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 保存会话失败: {str(e)}")
             return False
 
     def restore(self, file_path: str) -> bool:
@@ -380,13 +374,13 @@ class KimiModel(BasePlatform):
             self.uploaded_files = state.get("uploaded_files", [])
             self._saved = True
 
-            PrettyOutput.print(f"从 {file_path} 成功恢复会话", OutputType.SUCCESS)
+            print(f"✅ 从 {file_path} 成功恢复会话")
             return True
         except FileNotFoundError:
-            PrettyOutput.print(f"会话文件未找到: {file_path}", OutputType.ERROR)
+            print(f"❌ 会话文件未找到: {file_path}")
             return False
         except Exception as e:
-            PrettyOutput.print(f"恢复会话失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 恢复会话失败: {str(e)}")
             return False
 
     def name(self) -> str:

jarvis/jarvis_platform/openai.py

@@ -6,7 +6,6 @@ from typing import Dict, Generator, List, Tuple
 from openai import OpenAI
 
 from jarvis.jarvis_platform.base import BasePlatform
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 class OpenAIModel(BasePlatform):
@@ -19,12 +18,37 @@ class OpenAIModel(BasePlatform):
         self.system_message = ""
         self.api_key = os.getenv("OPENAI_API_KEY")
         if not self.api_key:
-            PrettyOutput.print("OPENAI_API_KEY 未设置", OutputType.WARNING)
+            print("⚠️ OPENAI_API_KEY 未设置")
 
         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:
+                    print("⚠️ OPENAI_EXTRA_HEADERS 应为 JSON 对象，如 {'X-Source':'jarvis'}")
+            except Exception as e:
+                print(f"⚠️ 解析 OPENAI_EXTRA_HEADERS 失败: {e}")
+
+        # 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:
+                print("⚠️ 当前 OpenAI SDK 不支持 default_headers，未能注入额外 HTTP 头")
         self.messages: List[Dict[str, str]] = []
         self.system_message = ""
 
@@ -57,7 +81,7 @@ class OpenAIModel(BasePlatform):
                 model_list.append((model.id, model.id))
             return model_list
         except Exception as e:
-            PrettyOutput.print(f"获取模型列表失败：{str(e)}", OutputType.ERROR)
+            print(f"❌ 获取模型列表失败：{str(e)}")
             return []
 
     def set_model_name(self, model_name: str):
@@ -100,26 +124,65 @@ class OpenAIModel(BasePlatform):
             # Add user message to history
             self.messages.append({"role": "user", "content": message})
 
-            response = self.client.chat.completions.create(
-                model=self.model_name,  # Use the configured model name
-                messages=self.messages,  # type: ignore
-                stream=True,
-            )  # type: ignore
-
-            full_response = ""
-            for chunk in response:
-                if chunk.choices and chunk.choices[0].delta.content:
-                    text = chunk.choices[0].delta.content
-                    full_response += text
-                    yield text
-
-            # Add assistant reply to history
-            self.messages.append({"role": "assistant", "content": full_response})
+            # 累计完整响应
+            accumulated_response = ""
+            
+            # 循环处理，直到不是因为长度限制而结束
+            while True:
+                response = self.client.chat.completions.create(
+                    model=self.model_name,  # Use the configured model name
+                    messages=self.messages,  # type: ignore
+                    stream=True,
+                )  # type: ignore
+
+                full_response = ""
+                finish_reason = None
+                
+                for chunk in response:
+                    if chunk.choices and len(chunk.choices) > 0:
+                        choice = chunk.choices[0]
+                        
+                        # 检查 finish_reason（通常在最后一个 chunk 中）
+                        if choice.finish_reason:
+                            finish_reason = choice.finish_reason
+                        
+                        # 获取内容增量
+                        if choice.delta and choice.delta.content:
+                            text = choice.delta.content
+                            full_response += text
+                            accumulated_response += text
+                            yield text
+
+                # 如果是因为长度限制而结束，继续获取剩余内容
+                if finish_reason == "length":
+                    # 将已获取的内容追加到消息历史中，以便下次请求时模型知道已生成的内容
+                    if self.messages and self.messages[-1].get("role") == "assistant":
+                        # 追加到现有的 assistant 消息
+                        self.messages[-1]["content"] += full_response
+                    else:
+                        # 创建新的 assistant 消息
+                        self.messages.append({"role": "assistant", "content": full_response})
+                    
+                    # 添加一个继续请求的用户消息，让模型继续生成
+                    self.messages.append({"role": "user", "content": "请继续。"})
+                    # 继续循环，获取剩余内容
+                    continue
+                else:
+                    # 正常结束（stop、null 或其他原因）
+                    # 将完整响应添加到消息历史
+                    if accumulated_response:
+                        if self.messages and self.messages[-1].get("role") == "assistant":
+                            # 如果最后一条是 assistant 消息，追加本次的内容
+                            self.messages[-1]["content"] += full_response
+                        else:
+                            # 创建新的 assistant 消息，使用累计的完整响应
+                            self.messages.append({"role": "assistant", "content": accumulated_response})
+                    break
 
             return None
 
         except Exception as e:
-            PrettyOutput.print(f"对话失败：{str(e)}", OutputType.ERROR)
+            print(f"❌ 对话失败：{str(e)}")
             raise Exception(f"Chat failed: {str(e)}")
 
     def name(self) -> str:
@@ -168,10 +231,10 @@ class OpenAIModel(BasePlatform):
             with open(file_path, "w", encoding="utf-8") as f:
                 json.dump(state, f, ensure_ascii=False, indent=4)
             self._saved = True
-            PrettyOutput.print(f"会话已成功保存到 {file_path}", OutputType.SUCCESS)
+            print(f"✅ 会话已成功保存到 {file_path}")
             return True
         except Exception as e:
-            PrettyOutput.print(f"保存会话失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 保存会话失败: {str(e)}")
             return False
 
     def restore(self, file_path: str) -> bool:
@@ -185,13 +248,13 @@ class OpenAIModel(BasePlatform):
             # atexit.register(self.delete_chat)
             self._saved = True
 
-            PrettyOutput.print(f"从 {file_path} 成功恢复会话", OutputType.SUCCESS)
+            print(f"✅ 从 {file_path} 成功恢复会话")
             return True
         except FileNotFoundError:
-            PrettyOutput.print(f"会话文件未找到: {file_path}", OutputType.ERROR)
+            print(f"❌ 会话文件未找到: {file_path}")
             return False
         except Exception as e:
-            PrettyOutput.print(f"恢复会话失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 恢复会话失败: {str(e)}")
             return False
 
     def support_web(self) -> bool:

jarvis/jarvis_platform/registry.py

@@ -7,11 +7,14 @@ from typing import Dict, List, Optional, Type
 
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_utils.config import (
+    get_cheap_model_name,
+    get_cheap_platform_name,
     get_data_dir,
     get_normal_model_name,
     get_normal_platform_name,
+    get_smart_model_name,
+    get_smart_platform_name,
 )
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 REQUIRED_METHODS = [
     ("chat", ["message"]),  # 方法名和参数列表
@@ -42,7 +45,7 @@ class PlatformRegistry:
                 ):
                     pass
             except Exception as e:
-                PrettyOutput.print(f"创建平台目录失败: {str(e)}", OutputType.ERROR)
+                print(f"❌ 创建平台目录失败: {str(e)}")
                 return ""
         return user_platform_dir
 
@@ -77,10 +80,7 @@ class PlatformRegistry:
                 missing_methods.append(f"{method_name}(parameter mismatch)")
 
         if missing_methods:
-            PrettyOutput.print(
-                f"平台 {platform_class.__name__} 缺少必要的方法: {', '.join(missing_methods)}",
-                OutputType.WARNING,
-            )
+            print(f"⚠️ 平台 {platform_class.__name__} 缺少必要的方法: {', '.join(missing_methods)}")
             return False
 
         return True
@@ -99,7 +99,7 @@ class PlatformRegistry:
 
         # 确保目录存在
         if not os.path.exists(directory):
-            PrettyOutput.print(f"平台目录不存在: {directory}", OutputType.WARNING)
+            print(f"⚠️ 平台目录不存在: {directory}")
             return platforms
 
         # 获取目录的包名
@@ -149,7 +149,8 @@ class PlatformRegistry:
                     error_lines.append(f"加载平台 {module_name} 失败: {str(e)}")
 
         if error_lines:
-            PrettyOutput.print("\n".join(error_lines), OutputType.ERROR)
+            joined_errors = '\n'.join(error_lines)
+            print(f"❌ {joined_errors}")
         return platforms
 
     @staticmethod
@@ -179,13 +180,28 @@ class PlatformRegistry:
                 self.register_platform(platform_name, platform_class)
 
     def get_normal_platform(self) -> BasePlatform:
+        """获取正常操作的平台实例"""
         platform_name = get_normal_platform_name()
         model_name = get_normal_model_name()
         platform = self.create_platform(platform_name)
         platform.set_model_name(model_name)  # type: ignore
         return platform  # type: ignore
 
+    def get_cheap_platform(self) -> BasePlatform:
+        """获取廉价操作的平台实例"""
+        platform_name = get_cheap_platform_name()
+        model_name = get_cheap_model_name()
+        platform = self.create_platform(platform_name)
+        platform.set_model_name(model_name)  # type: ignore
+        return platform  # type: ignore
 
+    def get_smart_platform(self) -> BasePlatform:
+        """获取智能操作的平台实例"""
+        platform_name = get_smart_platform_name()
+        model_name = get_smart_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
@@ -207,7 +223,7 @@ class PlatformRegistry:
             BasePlatform: Platform instance
         """
         if name not in self.platforms:
-            PrettyOutput.print(f"未找到平台: {name}", OutputType.WARNING)
+            print(f"⚠️ 未找到平台: {name}")
             return None
 
         try:
@@ -215,7 +231,7 @@ class PlatformRegistry:
             platform = self.platforms[name]()
             return platform
         except Exception as e:
-            PrettyOutput.print(f"创建平台失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 创建平台失败: {str(e)}")
             return None
 
     def get_available_platforms(self) -> List[str]: