jarvis-ai-assistant 0.1.96__py3-none-any.whl → 0.1.98__py3-none-any.whl

jarvis/jarvis_smart_shell/main.py

@@ -11,33 +11,33 @@ from jarvis.models.registry import PlatformRegistry
 from jarvis.utils import PrettyOutput, OutputType, load_env_from_file
 
 def execute_command(command: str) -> None:
-    """显示命令并允许用户编辑，回车执行，Ctrl+C取消"""
+    """Show command and allow user to edit, then execute, Ctrl+C to cancel"""
     try:
-        print("\n生成的命令 (可以编辑，回车执行，Ctrl+C取消):")
-        # 预填充输入行
+        print("\nGenerated command (can be edited, press Enter to execute, Ctrl+C to cancel):")
+        # Pre-fill input line
         readline.set_startup_hook(lambda: readline.insert_text(command))
         try:
             edited_command = input("> ")
-            if edited_command.strip():  # 确保命令不为空
+            if edited_command.strip():  # Ensure command is not empty
                 os.system(edited_command)
         except KeyboardInterrupt:
-            print("\n已取消执行")
+            print("\nExecution cancelled")
         finally:
-            readline.set_startup_hook()  # 清除预填充
+            readline.set_startup_hook()  # Clear pre-filled
     except Exception as e:
-        PrettyOutput.print(f"执行命令时发生错误: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"Failed to execute command: {str(e)}", OutputType.ERROR)
 
 def process_request(request: str) -> Optional[str]:
-    """处理用户请求并返回对应的shell命令
+    """Process user request and return corresponding shell command
     
     Args:
-        request: 用户的自然语言请求
+        request: User's natural language request
         
     Returns:
-        Optional[str]: 对应的shell命令，如果处理失败则返回None
+        Optional[str]: Corresponding shell command, return None if processing fails
     """
     try:
-        # 获取语言模型实例
+        # Get language model instance
         PlatformRegistry.suppress_output = True
         model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
         model.set_suppress_output(True)
@@ -45,35 +45,35 @@ def process_request(request: str) -> Optional[str]:
         shell = os.environ.get("SHELL") or "bash"
         current_path = os.getcwd()
         
-        # 设置系统提示
-        system_message = f"""你是一个 shell 命令生成助手。
+        # Set system prompt
+        system_message = f"""You are a shell command generation assistant.
 
-你的唯一任务是将用户的自然语言需求转换为对应的shell命令。
+Your only task is to convert user's natural language requirements into corresponding shell commands.
 
-严格要求：
-1. 只返回shell命令本身
-2. 不要添加任何标记（如```、/**/、//等）
-3. 不要添加任何解释或说明
-4. 不要添加任何换行或额外空格
-5. 如果需要多个命令，使用 && 连接
+Strict requirements:
+1. Only return the shell command itself
+2. Do not add any markers (like ```, /**/, // etc.)
+3. Do not add any explanations or descriptions
+4. Do not add any line breaks or extra spaces
+5. If multiple commands are needed, connect them with &&
 
-示例输入：
-"查找当前目录下的所有Python文件"
+Example input:
+"Find all Python files in the current directory"
 
-示例输出：
+Example output:
 find . -name "*.py"
 
-记住：只返回命令本身，不要有任何额外的内容。
+Remember: Only return the command itself, without any additional content.
 """
         model.set_system_message(system_message)
 
-        prefix = f"当前路径: {current_path}\n"
-        prefix += f"当前shell: {shell}\n"
+        prefix = f"Current path: {current_path}\n"
+        prefix += f"Current shell: {shell}\n"
         
         # 使用yaspin显示Thinking状态
         with yaspin(Spinners.dots, text="Thinking", color="yellow") as spinner:
             # 处理请求
-            result = model.chat(prefix + request)
+            result = model.chat_until_success(prefix + request)
             
             # 提取命令
             if result and isinstance(result, str):
@@ -85,26 +85,26 @@ find . -name "*.py"
             return None
         
     except Exception as e:
-        PrettyOutput.print(f"处理请求时发生错误: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"Failed to process request: {str(e)}", OutputType.ERROR)
         return None
 
 def main():
     # 创建参数解析器
     load_env_from_file()
     parser = argparse.ArgumentParser(
-        description="将自然语言需求转换为shell命令",
+        description="Convert natural language requirements to shell commands",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
-示例:
-  %(prog)s "查找当前目录下所有的Python文件"
-  %(prog)s "压缩所有jpg图片"
-  %(prog)s "查找最近一周修改过的文档"
+Example:
+  %(prog)s "Find all Python files in the current directory"
+  %(prog)s "Compress all jpg images"
+  %(prog)s "Find documents modified in the last week"
 """)
     
     # 添加参数
     parser.add_argument(
         "request",
-        help="用自然语言描述你需要执行的操作"
+        help="Describe the operation you want to perform in natural language"
     )
     
     # 解析参数

jarvis/main.py

@@ -10,7 +10,7 @@ from prompt_toolkit import prompt
 
 from jarvis.models.registry import PlatformRegistry
 
-# 添加父目录到Python路径以支持导入
+# Add parent directory to Python path to support imports    
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from jarvis.agent import Agent
@@ -22,7 +22,7 @@ def load_tasks() -> dict:
     """Load tasks from .jarvis files in user home and current directory."""
     tasks = {}
     
-    # 检查用户目录下的 .jarvis
+    # Check .jarvis in user directory
     user_jarvis = os.path.expanduser("~/.jarvis")
     if os.path.exists(user_jarvis):
         try:
@@ -30,39 +30,39 @@ def load_tasks() -> dict:
                 user_tasks = yaml.safe_load(f)
                 
             if isinstance(user_tasks, dict):
-                # 验证并添加用户目录的任务
+                # Validate and add user directory tasks
                 for name, desc in user_tasks.items():
-                    if desc:  # 确保描述不为空
+                    if desc:  # Ensure description is not empty
                         tasks[str(name)] = str(desc)
             else:
                 PrettyOutput.print("Warning: ~/.jarvis file should contain a dictionary of task_name: task_description", OutputType.ERROR)
         except Exception as e:
             PrettyOutput.print(f"Error loading ~/.jarvis file: {str(e)}", OutputType.ERROR)
     
-    # 检查当前目录下的 .jarvis
+    # Check .jarvis in current directory
     if os.path.exists(".jarvis"):
         try:
             with open(".jarvis", "r", encoding="utf-8") as f:
                 local_tasks = yaml.safe_load(f)
                 
             if isinstance(local_tasks, dict):
-                # 验证并添加当前目录的任务，如果有重名则覆盖用户目录的任务
+                # Validate and add current directory tasks, overwrite user directory tasks if there is a name conflict
                 for name, desc in local_tasks.items():
-                    if desc:  # 确保描述不为空
+                    if desc:  # Ensure description is not empty
                         tasks[str(name)] = str(desc)
             else:
                 PrettyOutput.print("Warning: .jarvis file should contain a dictionary of task_name: task_description", OutputType.ERROR)
         except Exception as e:
             PrettyOutput.print(f"Error loading .jarvis file: {str(e)}", OutputType.ERROR)
 
-    # 读取方法论
+    # Read methodology
     method_path = os.path.expanduser("~/.jarvis_methodology")
     if os.path.exists(method_path):
         with open(method_path, "r", encoding="utf-8") as f:
             methodology = yaml.safe_load(f)
         if isinstance(methodology, dict):
             for name, desc in methodology.items():
-                tasks[f"执行方法论：{str(name)}\n {str(desc)}" ] = str(desc)
+                tasks[f"Run Methodology: {str(name)}\n {str(desc)}" ] = str(desc)
     
     return tasks
 
@@ -77,13 +77,13 @@ def select_task(tasks: dict) -> str:
     PrettyOutput.print("\nAvailable tasks:", OutputType.INFO)
     for i, name in enumerate(task_names, 1):
         PrettyOutput.print(f"[{i}] {name}", OutputType.INFO)
-    PrettyOutput.print("[0] 跳过预定义任务", OutputType.INFO)
+    PrettyOutput.print("[0] Skip predefined tasks", OutputType.INFO)
     
     
     while True:
         try:
             choice = prompt(
-                "\n请选择一个任务编号(0跳过): ",
+                "\nPlease select a task number (0 to skip): ",
             ).strip()
             
             if not choice:
@@ -103,16 +103,16 @@ def select_task(tasks: dict) -> str:
         except EOFError:
             return ""  # Return empty on Ctrl+D
         except Exception as e:
-            PrettyOutput.print(f"选择失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to select task: {str(e)}", OutputType.ERROR)
             continue
 
 def main():
-    """Jarvis 的主入口点"""
-    # 添加参数解析器
+    """Jarvis main entry point"""
+    # Add argument parser
     load_env_from_file()
-    parser = argparse.ArgumentParser(description='Jarvis AI 助手')
-    parser.add_argument('-f', '--files', nargs='*', help='要处理的文件列表')
-    parser.add_argument('--keep-history', action='store_true', help='保持聊天历史(不删除会话)')
+    parser = argparse.ArgumentParser(description='Jarvis AI assistant')
+    parser.add_argument('-f', '--files', nargs='*', help='List of files to process')
+    parser.add_argument('--keep-history', action='store_true', help='Keep chat history (do not delete session)')
     args = parser.parse_args()
 
     try:
@@ -121,32 +121,32 @@ def main():
 
         # 如果用户传入了模型参数，则更换当前模型为用户指定的模型
 
-        # 欢迎信息
-        PrettyOutput.print(f"Jarvis 已初始化 - With {agent.model.name()}", OutputType.SYSTEM)
+        # Welcome information
+        PrettyOutput.print(f"Jarvis initialized - With {agent.model.name()}", OutputType.SYSTEM)
         if args.keep_history:
-            PrettyOutput.print("已启用历史保留模式", OutputType.INFO)
+            PrettyOutput.print("History preservation mode enabled", OutputType.INFO)
         
         # 加载预定义任务
         tasks = load_tasks()
         if tasks:
             selected_task = select_task(tasks)
             if selected_task:
-                PrettyOutput.print(f"\n执行任务: {selected_task}", OutputType.INFO)
+                PrettyOutput.print(f"\nExecute task: {selected_task}", OutputType.INFO)
                 agent.run(selected_task, args.files)
                 return 0
         
         # 如果没有选择预定义任务，进入交互模式
         while True:
             try:
-                user_input = get_multiline_input("请输入您的任务(输入空行退出):")
+                user_input = get_multiline_input("Please enter your task (input empty line to exit):")
                 if not user_input or user_input == "__interrupt__":
                     break
                 agent.run(user_input, args.files)
             except Exception as e:
-                PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
+                PrettyOutput.print(f"Error: {str(e)}", OutputType.ERROR)
 
     except Exception as e:
-        PrettyOutput.print(f"初始化错误: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"Initialization error: {str(e)}", OutputType.ERROR)
         return 1
 
     return 0

jarvis/models/ai8.py

@@ -26,16 +26,16 @@ class AI8Model(BasePlatform):
 
         self.token = os.getenv("AI8_API_KEY")
         if not self.token:
-            PrettyOutput.print("AI8_API_KEY未设置", OutputType.WARNING)
+            PrettyOutput.print("AI8_API_KEY is not set", OutputType.WARNING)
         
         
         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)
+            PrettyOutput.print(f"Warning: The selected model {self.model_name} is not in the available list", OutputType.WARNING)
         
 
     def set_model_name(self, model_name: str):
-        """设置模型名称"""
+        """Set model name"""
 
         self.model_name = model_name
             
@@ -59,12 +59,12 @@ class AI8Model(BasePlatform):
             )
             
             if response.status_code != 200:
-                PrettyOutput.print(f"创建会话失败: {response.status_code}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to create session: {response.status_code}", OutputType.ERROR)
                 return False
             
             data = response.json()
             if data['code'] != 0:
-                PrettyOutput.print(f"创建会话失败: {data.get('msg', '未知错误')}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to create session: {data.get('msg', 'Unknown error')}", OutputType.ERROR)
                 return False
             
             self.conversation = data['data']
@@ -92,14 +92,14 @@ class AI8Model(BasePlatform):
                     self.conversation = data['data']
                     return True
                 else:
-                    PrettyOutput.print(f"更新会话设置失败: {data.get('msg', '未知错误')}", OutputType.ERROR)
+                    PrettyOutput.print(f"Failed to update session settings: {data.get('msg', 'Unknown error')}", OutputType.ERROR)
                     return False
             else:
-                PrettyOutput.print(f"更新会话设置失败: {response.status_code}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to update session settings: {response.status_code}", OutputType.ERROR)
                 return False
             
         except Exception as e:
-            PrettyOutput.print(f"创建会话异常: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to create session: {str(e)}", OutputType.ERROR)
             return False
         
     def upload_files(self, file_list: List[str]) -> List[Dict]:
@@ -119,7 +119,7 @@ class AI8Model(BasePlatform):
         self.system_message = message
         
     def chat(self, message: str) -> str:
-        """执行对话"""
+        """Execute conversation"""
         try:
             
             # 确保有会话ID
@@ -160,7 +160,7 @@ class AI8Model(BasePlatform):
             )
             
             if response.status_code != 200:
-                error_msg = f"聊天请求失败: {response.status_code}"
+                error_msg = f"Failed to chat: {response.status_code}"
                 PrettyOutput.print(error_msg, OutputType.ERROR)
                 raise Exception(error_msg)
             
@@ -188,7 +188,7 @@ class AI8Model(BasePlatform):
             return full_response
             
         except Exception as e:
-            PrettyOutput.print(f"聊天异常: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Chat exception: {str(e)}", OutputType.ERROR)
             raise e
             
     def name(self) -> str:
@@ -227,23 +227,23 @@ class AI8Model(BasePlatform):
                     self.reset()
                     return True
                 else:
-                    error_msg = f"删除会话失败: {data.get('msg', '未知错误')}"
+                    error_msg = f"Failed to delete session: {data.get('msg', 'Unknown error')}"
                     PrettyOutput.print(error_msg, OutputType.ERROR)
                     return False
             else:
-                error_msg = f"删除会话请求失败: {response.status_code}"
+                error_msg = f"Failed to delete session request: {response.status_code}"
                 PrettyOutput.print(error_msg, OutputType.ERROR)
                 return False
             
         except Exception as e:
-            PrettyOutput.print(f"删除会话异常: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to delete session: {str(e)}", OutputType.ERROR)
             return False
         
     def get_available_models(self) -> List[str]:
-        """获取可用的模型列表
+        """Get available model list
         
         Returns:
-            List[str]: 可用模型名称列表
+            List[str]: Available model name list
         """
         try:
             if self.models:
@@ -264,12 +264,12 @@ class AI8Model(BasePlatform):
             )
             
             if response.status_code != 200:
-                PrettyOutput.print(f"获取模型列表失败: {response.status_code}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to get model list: {response.status_code}", OutputType.ERROR)
                 return []
             
             data = response.json()
             if data['code'] != 0:
-                PrettyOutput.print(f"获取模型列表失败: {data.get('msg', '未知错误')}", OutputType.ERROR)
+                PrettyOutput.print(f"Failed to get model list: {data.get('msg', 'Unknown error')}", OutputType.ERROR)
                 return []
             
             # 保存模型信息
@@ -292,11 +292,11 @@ class AI8Model(BasePlatform):
                 # 添加特性标记
                 features = []
                 if model['attr'].get('multimodal'):
-                    features.append("多模态")
+                    features.append("Multimodal")
                 if model['attr'].get('plugin'):
-                    features.append("插件支持")
+                    features.append("Plugin support")
                 if model['attr'].get('onlyImg'):
-                    features.append("图像支持")
+                    features.append("Image support")
                 if features:
                     model_str += f" [{'|'.join(features)}]"
                     
@@ -308,6 +308,6 @@ class AI8Model(BasePlatform):
             return list(self.models.keys())
             
         except Exception as e:
-            PrettyOutput.print(f"获取模型列表异常: {str(e)}", OutputType.WARNING)
+            PrettyOutput.print(f"Failed to get model list: {str(e)}", OutputType.WARNING)
             return []
         

jarvis/models/base.py

@@ -1,59 +1,63 @@
 from abc import ABC, abstractmethod
 from typing import Dict, List, Tuple
 
+from jarvis.utils import OutputType, PrettyOutput, while_success, while_true
+
 
 class BasePlatform(ABC):
-    """大语言模型基类"""
+    """Base class for large language models"""
     
     def __init__(self):
-        """初始化模型"""
+        """Initialize model"""
         self.suppress_output = False  # 添加输出控制标志
-        pass
 
     def __del__(self):
-        """销毁模型"""
+        """Destroy model"""
         self.delete_chat()
 
     @abstractmethod
     def set_model_name(self, model_name: str):
-        """设置模型名称"""
+        """Set model name"""
         raise NotImplementedError("set_model_name is not implemented")
         
     @abstractmethod
     def chat(self, message: str) -> str:
-        """执行对话"""
+        """Execute conversation"""
         raise NotImplementedError("chat is not implemented")
 
+    def chat_until_success(self, message: str) -> str:
+        return while_true(lambda: while_success(lambda: self.chat(message), 5), 5)
+
     @abstractmethod
     def upload_files(self, file_list: List[str]) -> List[Dict]:
-        """上传文件"""
+        """Upload files"""
         raise NotImplementedError("upload_files is not implemented")
 
     @abstractmethod
     def reset(self):
-        """重置模型"""
+        """Reset model"""
         raise NotImplementedError("reset is not implemented")
         
     @abstractmethod
     def name(self) -> str:
-        """模型名称"""
+        """Model name"""
         raise NotImplementedError("name is not implemented")
     
     @abstractmethod
     def delete_chat(self)->bool:
-        """删除对话"""
+        """Delete chat"""
         raise NotImplementedError("delete_chat is not implemented")
     
     @abstractmethod
     def set_system_message(self, message: str):
-        """设置系统消息"""
+        """Set system message"""
         raise NotImplementedError("set_system_message is not implemented")
     
     @abstractmethod
     def get_model_list(self) -> List[Tuple[str, str]]:
-        """获取模型列表"""
+        """Get model list"""
         raise NotImplementedError("get_model_list is not implemented")
 
     def set_suppress_output(self, suppress: bool):
-        """设置是否屏蔽输出"""
+        """Set whether to suppress output"""
         self.suppress_output = suppress

jarvis/models/kimi.py

@@ -9,38 +9,38 @@ from jarvis.utils import PrettyOutput, OutputType
 from jarvis.utils import while_success
 
 class KimiModel(BasePlatform):
-    """Kimi模型实现"""
+    """Kimi model implementation"""
 
     platform_name = "kimi"
 
     def get_model_list(self) -> List[Tuple[str, str]]:
-        """获取模型列表"""
-        return [("kimi", "基于网页Kimi的封装，免费接口")]
+        """Get model list"""
+        return [("kimi", "Based on the web Kimi, free interface")]
     
     def __init__(self):
         """
-        初始化Kimi模型
+        Initialize Kimi model
         """
         super().__init__()
         self.chat_id = ""
         self.api_key = os.getenv("KIMI_API_KEY")
         if not self.api_key:
-            PrettyOutput.print("\n需要设置 KIMI_API_KEY 才能使用 Jarvis。请按以下步骤操作：", OutputType.INFO)
-            PrettyOutput.print("\n1. 获取 Kimi API Key:", OutputType.INFO)
-            PrettyOutput.print("   • 访问 Kimi AI 平台: https://kimi.moonshot.cn", OutputType.INFO)
-            PrettyOutput.print("   • 登录您的账号", OutputType.INFO)
-            PrettyOutput.print("   • 打开浏览器开发者工具 (F12 或右键 -> 检查)", OutputType.INFO)
-            PrettyOutput.print("   • 切换到 Network 标签页", OutputType.INFO)
-            PrettyOutput.print("   • 发送任意消息", OutputType.INFO)
-            PrettyOutput.print("   • 在请求中找到 Authorization 头部", OutputType.INFO)
-            PrettyOutput.print("   • 复制 token 值（去掉 'Bearer ' 前缀）", OutputType.INFO)
-            PrettyOutput.print("\n2. 设置环境变量:", OutputType.INFO)
-            PrettyOutput.print("   方法 1: 创建或编辑 ~/.jarvis_env 文件:", OutputType.INFO)
+            PrettyOutput.print("\nNeed to set KIMI_API_KEY to use Jarvis. Please follow the steps below:", OutputType.INFO)
+            PrettyOutput.print("\n1. Get Kimi API Key:", OutputType.INFO)
+            PrettyOutput.print("   • Visit Kimi AI platform: https://kimi.moonshot.cn", OutputType.INFO)
+            PrettyOutput.print("   • Login to your account", OutputType.INFO)
+            PrettyOutput.print("   • Open browser developer tools (F12 or right-click -> Inspect)", OutputType.INFO)
+            PrettyOutput.print("   • Switch to the Network tab", OutputType.INFO)
+            PrettyOutput.print("   • Send any message", OutputType.INFO)
+            PrettyOutput.print("   • Find the Authorization header in the request", OutputType.INFO)
+            PrettyOutput.print("   • Copy the token value (remove the 'Bearer ' prefix)", OutputType.INFO)
+            PrettyOutput.print("\n2. Set environment variable:", OutputType.INFO)
+            PrettyOutput.print("   • Method 1: Create or edit ~/.jarvis_env file:", OutputType.INFO)
             PrettyOutput.print("   echo 'KIMI_API_KEY=your_key_here' > ~/.jarvis_env", OutputType.INFO)
-            PrettyOutput.print("\n   方法 2: 直接设置环境变量:", OutputType.INFO)
+            PrettyOutput.print("\n   • Method 2: Set environment variable directly:", OutputType.INFO)
             PrettyOutput.print("   export KIMI_API_KEY=your_key_here", OutputType.INFO)
-            PrettyOutput.print("\n设置完成后重新运行 Jarvis。", OutputType.INFO)
-            PrettyOutput.print("KIMI_API_KEY未设置", OutputType.WARNING)
+            PrettyOutput.print("\nAfter setting, run Jarvis again.", OutputType.INFO)
+            PrettyOutput.print("KIMI_API_KEY is not set", OutputType.WARNING)
         self.auth_header = f"Bearer {self.api_key}"
         self.chat_id = ""
         self.uploaded_files = []  # 存储已上传文件的信息
@@ -48,18 +48,18 @@ class KimiModel(BasePlatform):
         self.system_message = ""
 
     def set_system_message(self, message: str):
-        """设置系统消息"""
+        """Set system message"""
         self.system_message = message
 
     def set_model_name(self, model_name: str):
-        """设置模型名称"""
+        """Set model name"""
         pass
 
     def _create_chat(self) -> bool:
-        """创建新的对话会话"""
+        """Create a new chat session"""
         url = "https://kimi.moonshot.cn/api/chat"
         payload = json.dumps({
-            "name": "未命名会话",
+            "name": "Unnamed session",
             "is_example": False,
             "kimiplus_id": "kimi"
         })
@@ -76,7 +76,7 @@ class KimiModel(BasePlatform):
             return False
 
     def _get_presigned_url(self, filename: str, action: str) -> Dict:
-        """获取预签名上传URL"""
+        """Get presigned upload URL"""
         url = "https://kimi.moonshot.cn/api/pre-sign-url"
         
         
@@ -95,7 +95,7 @@ class KimiModel(BasePlatform):
         return response.json()
 
     def _upload_file(self, file_path: str, presigned_url: str) -> bool:
-        """上传文件到预签名URL"""
+        """Upload file to presigned URL"""
         try:
             with open(file_path, 'rb') as f:
                 content = f.read()
@@ -106,7 +106,7 @@ class KimiModel(BasePlatform):
             return False
 
     def _get_file_info(self, file_data: Dict, name: str, file_type: str) -> Dict:
-        """获取文件信息"""
+        """Get file information"""
         url = "https://kimi.moonshot.cn/api/file"
         payload = json.dumps({
             "type": file_type,
@@ -125,7 +125,7 @@ class KimiModel(BasePlatform):
         return response.json()
 
     def _wait_for_parse(self, file_id: str) -> bool:
-        """等待文件解析完成"""
+        """Wait for file parsing to complete"""
         url = "https://kimi.moonshot.cn/api/file/parse_process"
         headers = {
             'Authorization': self.auth_header,
@@ -163,7 +163,7 @@ class KimiModel(BasePlatform):
         
         return False
     def upload_files(self, file_list: List[str]) -> List[Dict]:
-        """上传文件列表并返回文件信息"""
+        """Upload file list and return file information"""
         if not file_list:
             return []
 
@@ -209,7 +209,7 @@ class KimiModel(BasePlatform):
         return uploaded_files
 
     def chat(self, message: str) -> str:
-        """发送消息并获取响应"""
+        """Send message and get response"""
         if not self.chat_id:
             if not self._create_chat():
                 raise Exception("Failed to create chat session")
@@ -353,7 +353,7 @@ class KimiModel(BasePlatform):
             raise Exception(f"Chat failed: {str(e)}")
 
     def delete_chat(self) -> bool:
-        """删除当前会话"""
+        """Delete current session"""
         if not self.chat_id:
             return True  # 如果没有会话ID，视为删除成功
             
@@ -376,11 +376,11 @@ class KimiModel(BasePlatform):
             return False
 
     def reset(self):
-        """重置对话"""
+        """Reset chat"""
         self.chat_id = ""
         self.uploaded_files = []
         self.first_chat = True  # 重置first_chat标记
 
     def name(self) -> str:
-        """模型名称"""
+        """Model name"""
         return "kimi"