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

jarvis/models/ollama.py

@@ -6,56 +6,56 @@ import os
 import json
 
 class OllamaPlatform(BasePlatform):
-    """Ollama 平台实现"""
+    """Ollama platform implementation"""
     
     platform_name = "ollama"
     
     def __init__(self):
-        """初始化模型"""
+        """Initialize model"""
         super().__init__()
         
-        # 检查环境变量并提供帮助信息
+        # Check environment variables and provide help information
         self.api_base = os.getenv("OLLAMA_API_BASE", "http://localhost:11434")
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-r1:1.5b"
         
-        # 检查 Ollama 服务是否可用
+        # Check if Ollama service is available
         try:
             response = requests.get(f"{self.api_base}/api/tags")
             response.raise_for_status()
             available_models = [model["name"] for model in response.json().get("models", [])]
             
             if not available_models:
-                PrettyOutput.print("\n需要先下载 Ollama 模型才能使用：", OutputType.INFO)
-                PrettyOutput.print("1. 安装 Ollama: https://ollama.ai", OutputType.INFO)
-                PrettyOutput.print("2. 下载模型:", OutputType.INFO)
+                PrettyOutput.print("\nNeed to download Ollama model first to use:", OutputType.INFO)
+                PrettyOutput.print("1. Install Ollama: https://ollama.ai", OutputType.INFO)
+                PrettyOutput.print("2. Download model:", OutputType.INFO)
                 PrettyOutput.print(f"   ollama pull {self.model_name}", OutputType.INFO)
-                PrettyOutput.print("Ollama没有可用的模型", OutputType.WARNING)
+                PrettyOutput.print("Ollama has no available models", OutputType.WARNING)
                 
         except requests.exceptions.ConnectionError:
-            PrettyOutput.print("\nOllama 服务未启动或无法连接", OutputType.WARNING)
-            PrettyOutput.print("请确保已经：", OutputType.INFO)
-            PrettyOutput.print("1. 安装了 Ollama: https://ollama.ai", OutputType.INFO)
-            PrettyOutput.print("2. 启动了 Ollama 服务", OutputType.INFO)
-            PrettyOutput.print("3. 服务地址配置正确 (默认: http://localhost:11434)", OutputType.INFO)
+            PrettyOutput.print("\nOllama service is not started or cannot be connected", OutputType.WARNING)
+            PrettyOutput.print("Please ensure that you have:", OutputType.INFO)
+            PrettyOutput.print("1. Installed Ollama: https://ollama.ai", OutputType.INFO)
+            PrettyOutput.print("2. Started Ollama service", OutputType.INFO)
+            PrettyOutput.print("3. Service address configured correctly (default: http://localhost:11434)", OutputType.INFO)
             
             
         self.messages = []
         self.system_message = ""
 
     def get_model_list(self) -> List[Tuple[str, str]]:
-        """获取模型列表"""
+        """Get model list"""
         response = requests.get(f"{self.api_base}/api/tags")
         response.raise_for_status()
         return [(model["name"], "") for model in response.json().get("models", [])]
 
     def set_model_name(self, model_name: str):
-        """设置模型名称"""
+        """Set model name"""
         self.model_name = model_name
 
     def chat(self, message: str) -> str:
-        """执行对话"""
+        """Execute conversation"""
         try:
-            # 构建消息列表
+            # Build message list
             messages = []
             if self.system_message:
                 messages.append({"role": "system", "content": self.system_message})
@@ -102,31 +102,31 @@ class OllamaPlatform(BasePlatform):
             return full_response
             
         except Exception as e:
-            PrettyOutput.print(f"对话失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Chat failed: {str(e)}", OutputType.ERROR)
             raise Exception(f"Chat failed: {str(e)}")
 
     def upload_files(self, file_list: List[str]) -> List[Dict]:
-        """上传文件 (Ollama 不支持文件上传)"""
-        PrettyOutput.print("Ollama 不支持文件上传", output_type=OutputType.WARNING)
+        """Upload files (Ollama does not support file upload)"""
+        PrettyOutput.print("Ollama does not support file upload", output_type=OutputType.WARNING)
         return []
         
     def reset(self):
-        """重置模型状态"""
+        """Reset model state"""
         self.messages = []
         if self.system_message:
             self.messages.append({"role": "system", "content": self.system_message})
             
     def name(self) -> str:
-        """返回模型名称"""
+        """Return model name"""
         return self.model_name
             
     def delete_chat(self) -> bool:
-        """删除当前聊天会话"""
+        """Delete current chat session"""
         self.reset()
         return True
         
     def set_system_message(self, message: str):
-        """设置系统消息"""
+        """Set system message"""
         self.system_message = message
         self.reset()  # 重置会话以应用新的系统消息 
 
@@ -136,10 +136,10 @@ if __name__ == "__main__":
         ollama = OllamaPlatform()
         while True:
             try:
-                message = input("\n输入问题(Ctrl+C退出): ")
-                ollama.chat(message)
+                message = input("\nInput question (Ctrl+C to exit): ")
+                ollama.chat_until_success(message)
             except KeyboardInterrupt:
-                print("\n再见！")
+                print("\nGoodbye!")
                 break
     except Exception as e:
-        PrettyOutput.print(f"程序异常退出: {str(e)}", OutputType.ERROR)
+        PrettyOutput.print(f"Program exited with an exception: {str(e)}", OutputType.ERROR)

jarvis/models/openai.py

@@ -5,35 +5,33 @@ from jarvis.models.base import BasePlatform
 from jarvis.utils import PrettyOutput, OutputType
 
 class OpenAIModel(BasePlatform):
-    """DeepSeek模型实现"""
-
     platform_name = "openai"
 
     def upload_files(self, file_list: List[str]):
-        """上传文件"""
-        PrettyOutput.print("OpenAI 不支持上传文件", OutputType.WARNING)
+        """Upload files"""
+        PrettyOutput.print("OpenAI does not support file upload", OutputType.WARNING)
     
     def __init__(self):
         """
-        初始化DeepSeek模型
+        Initialize OpenAI model
         """
         super().__init__()
         self.system_message = ""
         self.api_key = os.getenv("OPENAI_API_KEY")
         if not self.api_key:
-            PrettyOutput.print("\n需要设置以下环境变量才能使用 OpenAI 模型：", OutputType.INFO)
-            PrettyOutput.print("  • OPENAI_API_KEY: API 密钥", OutputType.INFO)
-            PrettyOutput.print("  • OPENAI_API_BASE: (可选) API 基础地址，默认使用 https://api.openai.com/v1", OutputType.INFO)
-            PrettyOutput.print("\n可以通过以下方式设置：", OutputType.INFO)
-            PrettyOutput.print("1. 创建或编辑 ~/.jarvis_env 文件:", OutputType.INFO)
+            PrettyOutput.print("\nNeed to set the following environment variables to use OpenAI model:", OutputType.INFO)
+            PrettyOutput.print("  • OPENAI_API_KEY: API key", OutputType.INFO)
+            PrettyOutput.print("  • OPENAI_API_BASE: (optional) API base address, default using https://api.openai.com/v1", OutputType.INFO)
+            PrettyOutput.print("\nYou can set them in the following ways:", OutputType.INFO)
+            PrettyOutput.print("1. Create or edit ~/.jarvis_env file:", OutputType.INFO)
             PrettyOutput.print("   OPENAI_API_KEY=your_api_key", OutputType.INFO)
             PrettyOutput.print("   OPENAI_API_BASE=your_api_base", OutputType.INFO)
             PrettyOutput.print("   OPENAI_MODEL_NAME=your_model_name", OutputType.INFO)
-            PrettyOutput.print("\n2. 或者直接设置环境变量:", OutputType.INFO)
+            PrettyOutput.print("\n2. Or set the environment variables directly:", OutputType.INFO)
             PrettyOutput.print("   export OPENAI_API_KEY=your_api_key", OutputType.INFO)
             PrettyOutput.print("   export OPENAI_API_BASE=your_api_base", OutputType.INFO)
             PrettyOutput.print("   export OPENAI_MODEL_NAME=your_model_name", OutputType.INFO)
-            PrettyOutput.print("OPENAI_API_KEY未设置", OutputType.WARNING)
+            PrettyOutput.print("OPENAI_API_KEY is not set", OutputType.WARNING)
             
         self.base_url = os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1")
         self.model_name =  os.getenv("JARVIS_MODEL") or "gpt-4o"
@@ -47,28 +45,28 @@ class OpenAIModel(BasePlatform):
         self.system_message = ""
 
     def get_model_list(self) -> List[Tuple[str, str]]:
-        """获取模型列表"""
+        """Get model list"""
         return []
 
     def set_model_name(self, model_name: str):
-        """设置模型名称"""
+        """Set model name"""
 
         self.model_name = model_name
 
     def set_system_message(self, message: str):
-        """设置系统消息"""
+        """Set system message"""
         self.system_message = message
         self.messages.append({"role": "system", "content": self.system_message})
 
     def chat(self, message: str) -> str:
-        """执行对话"""
+        """Execute conversation"""
         try:
             
-            # 添加用户消息到历史记录
+            # Add user message to history
             self.messages.append({"role": "user", "content": message})
             
             response = self.client.chat.completions.create(
-                model=self.model_name,  # 使用配置的模型名称
+                model=self.model_name,  # Use the configured model name
                 messages=self.messages, # type: ignore
                 stream=True
             ) # type: ignore
@@ -85,28 +83,28 @@ class OpenAIModel(BasePlatform):
             if not self.suppress_output:
                 PrettyOutput.print_stream_end()
             
-            # 添加助手回复到历史记录
+            # Add assistant reply to history
             self.messages.append({"role": "assistant", "content": full_response})
             
             return full_response
             
         except Exception as e:
-            PrettyOutput.print(f"对话失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Chat failed: {str(e)}", OutputType.ERROR)
             raise Exception(f"Chat failed: {str(e)}")
 
     def name(self) -> str:
-        """返回模型名称"""
+        """Return model name"""
         return self.model_name
 
     def reset(self):
-        """重置模型状态"""
-        # 清空对话历史，只保留system message
+        """Reset model state"""
+        # Clear conversation history, only keep system message
         if self.system_message:
             self.messages = [{"role": "system", "content": self.system_message}]
         else:
             self.messages = []
 
     def delete_chat(self)->bool:
-        """删除对话"""
+        """Delete conversation"""
         self.reset()
         return True

jarvis/models/oyi.py

@@ -13,7 +13,7 @@ class OyiModel(BasePlatform):
     BASE_URL = "https://api-10086.rcouyi.com"
 
     def get_model_list(self) -> List[Tuple[str, str]]:
-        """获取模型列表"""
+        """Get model list"""
         return [(name,info['desc']) for name,info in self.models.items()]
     
     def __init__(self):
@@ -28,15 +28,15 @@ class OyiModel(BasePlatform):
         
         self.token = os.getenv("OYI_API_KEY")
         if not self.token:
-            PrettyOutput.print("OYI_API_KEY未设置", OutputType.WARNING)
+            PrettyOutput.print("OYI_API_KEY is not set", OutputType.WARNING)
         
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
         if self.model_name not in [m.split()[0] for m 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
 
@@ -54,7 +54,7 @@ class OyiModel(BasePlatform):
             payload = {
                 "id": 0,
                 "roleId": 0,
-                "title": "新对话",
+                "title": "New conversation",
                 "isLock": False,
                 "systemMessage": "",
                 "params": json.dumps({
@@ -82,14 +82,14 @@ class OyiModel(BasePlatform):
                     self.conversation = data
                     return True
                 else:
-                    PrettyOutput.print(f"创建会话失败: {data['message']}", OutputType.ERROR)
+                    PrettyOutput.print(f"Create conversation failed: {data['message']}", OutputType.ERROR)
                     return False
             else:
-                PrettyOutput.print(f"创建会话失败: {response.status_code}", OutputType.ERROR)
+                PrettyOutput.print(f"Create conversation failed: {response.status_code}", OutputType.ERROR)
                 return False
                 
         except Exception as e:
-            PrettyOutput.print(f"创建会话异常: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Create conversation failed: {str(e)}", OutputType.ERROR)
             return False
     
     def set_system_message(self, message: str):
@@ -155,13 +155,13 @@ class OyiModel(BasePlatform):
             )
             
             if response.status_code != 200:
-                error_msg = f"聊天请求失败: {response.status_code}"
+                error_msg = f"Chat request failed: {response.status_code}"
                 PrettyOutput.print(error_msg, OutputType.ERROR)
                 raise Exception(error_msg)
             
             data = response.json()
             if data['code'] != 200 or data['type'] != 'success':
-                error_msg = f"聊天失败: {data.get('message', '未知错误')}"
+                error_msg = f"Chat failed: {data.get('message', 'Unknown error')}"
                 PrettyOutput.print(error_msg, OutputType.ERROR)
                 raise Exception(error_msg)
             
@@ -179,12 +179,12 @@ class OyiModel(BasePlatform):
                 self.messages.append({"role": "assistant", "content": response.text})
                 return response.text
             else:
-                error_msg = f"获取响应失败: {response.status_code}"
+                error_msg = f"Get response failed: {response.status_code}"
                 PrettyOutput.print(error_msg, OutputType.ERROR)
                 raise Exception(error_msg)
             
         except Exception as e:
-            PrettyOutput.print(f"聊天异常: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Chat failed: {str(e)}", OutputType.ERROR)
             raise e
             
     def name(self) -> str:
@@ -225,16 +225,16 @@ class OyiModel(BasePlatform):
                     self.reset()
                     return True
                 else:
-                    error_msg = f"删除会话失败: {data.get('message', '未知错误')}"
+                    error_msg = f"Delete conversation failed: {data.get('message', 'Unknown error')}"
                     PrettyOutput.print(error_msg, OutputType.ERROR)
                     return False
             else:
-                error_msg = f"删除会话请求失败: {response.status_code}"
+                error_msg = f"Delete conversation request failed: {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"Delete conversation failed: {str(e)}", OutputType.ERROR)
             return False
     
     def upload_files(self, file_list: List[str]) -> List[Dict]:
@@ -250,7 +250,7 @@ class OyiModel(BasePlatform):
             # 检查当前模型是否支持文件上传
             model_info = self.models.get(self.model_name)
             if not model_info or not model_info.get('uploadFile', False):
-                PrettyOutput.print(f"当前模型 {self.model_name} 不支持文件上传", OutputType.WARNING)
+                PrettyOutput.print(f"The current model {self.model_name} does not support file upload", OutputType.WARNING)
                 return []
             
             headers = {
@@ -266,7 +266,7 @@ class OyiModel(BasePlatform):
                 # 检查文件类型
                 file_type = mimetypes.guess_type(file_path)[0]
                 if not file_type or not file_type.startswith(('image/', 'text/', 'application/')):
-                    PrettyOutput.print(f"文件类型不支持: {file_type}", OutputType.ERROR)
+                    PrettyOutput.print(f"The file type {file_type} is not supported", OutputType.ERROR)
                     continue
                 
                 with open(file_path, 'rb') as f:
@@ -285,22 +285,22 @@ class OyiModel(BasePlatform):
                         if data.get('code') == 200:
                             self.files.append(data)
                         else:
-                            PrettyOutput.print(f"文件上传失败: {data.get('message')}", OutputType.ERROR)
+                            PrettyOutput.print(f"File upload failed: {data.get('message')}", OutputType.ERROR)
                             return []
                     else:
-                        PrettyOutput.print(f"文件上传失败: {response.status_code}", OutputType.ERROR)
+                        PrettyOutput.print(f"File upload failed: {response.status_code}", OutputType.ERROR)
                         return []
                 
             return self.files
         except Exception as e:
-            PrettyOutput.print(f"文件上传异常: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"File upload failed: {str(e)}", OutputType.ERROR)
             return []
 
     def get_available_models(self) -> List[str]:
-        """获取可用的模型列表
+        """Get available model list
         
         Returns:
-            List[str]: 可用模型名称列表
+            List[str]: Available model name list
         """
         try:
             if self.models:
@@ -320,7 +320,7 @@ class OyiModel(BasePlatform):
             )
             
             if response.status_code != 200:
-                PrettyOutput.print(f"获取模型列表失败: {response.status_code}", OutputType.ERROR)
+                PrettyOutput.print(f"Get model list failed: {response.status_code}", OutputType.ERROR)
                 return []
             
             data = response.json()
@@ -357,12 +357,12 @@ class OyiModel(BasePlatform):
                     
                 # 添加文件上传支持标记
                 if model.get('uploadFile'):
-                    model_str += " [支持文件上传]"
+                    model_str += " [Support file upload]"
                 model['desc'] = model_str
                 models.append(model_name)
                 
             return sorted(models)
             
         except Exception as e:
-            PrettyOutput.print(f"获取模型列表异常: {str(e)}", OutputType.WARNING)
+            PrettyOutput.print(f"Get model list failed: {str(e)}", OutputType.WARNING)
             return []

jarvis/models/registry.py

@@ -19,7 +19,7 @@ REQUIRED_METHODS = [
 ]
 
 class PlatformRegistry:
-    """平台注册器"""
+    """Platform registry"""
 
     global_platform_name = "kimi"
     global_platform_registry = None
@@ -37,19 +37,19 @@ class PlatformRegistry:
 
                 pass
             except Exception as e:
-                PrettyOutput.print(f"创建平台目录失败: {str(e)}", OutputType.ERROR)
+                PrettyOutput.print(f"Create platform directory failed: {str(e)}", OutputType.ERROR)
                 return ""
         return user_platform_dir
 
     @staticmethod
     def check_platform_implementation(platform_class: Type[BasePlatform]) -> bool:
-        """检查平台类是否实现了所有必要的方法
+        """Check if the platform class implements all necessary methods
         
         Args:
-            platform_class: 要检查的平台类
+            platform_class: The platform class to check
             
         Returns:
-            bool: 是否实现了所有必要的方法
+            bool: Whether all necessary methods are implemented
         """
         missing_methods = []
         
@@ -68,11 +68,11 @@ class PlatformRegistry:
             sig = inspect.signature(method)
             method_params = [p for p in sig.parameters if p != 'self']
             if len(method_params) != len(params):
-                missing_methods.append(f"{method_name}(参数不匹配)")
+                missing_methods.append(f"{method_name}(parameter mismatch)")
         
         if missing_methods:
             PrettyOutput.print(
-                f"平台 {platform_class.__name__} 缺少必要的方法: {', '.join(missing_methods)}", 
+                f"Platform {platform_class.__name__} is missing necessary methods: {', '.join(missing_methods)}", 
                 OutputType.ERROR
             )
             return False
@@ -81,19 +81,19 @@ class PlatformRegistry:
 
     @staticmethod
     def load_platform_from_dir(directory: str) -> Dict[str, Type[BasePlatform]]:
-        """从指定目录加载平台
+        """Load platforms from specified directory
         
         Args:
-            directory: 平台目录路径
+            directory: Platform directory path
             
         Returns:
-            Dict[str, Type[BasePlatform]]: 平台名称到平台类的映射
+            Dict[str, Type[BasePlatform]]: Platform name to platform class mapping
         """
         platforms = {}
         
         # 确保目录存在
         if not os.path.exists(directory):
-            PrettyOutput.print(f"平台目录不存在: {directory}", OutputType.ERROR)
+            PrettyOutput.print(f"Platform directory does not exist: {directory}", OutputType.ERROR)
             return platforms
             
         # 获取目录的包名
@@ -127,18 +127,18 @@ class PlatformRegistry:
                             if not PlatformRegistry.check_platform_implementation(obj):
                                 continue
                             if not PlatformRegistry.suppress_output:
-                                PrettyOutput.print(f"从 {os.path.join(directory, filename)} 加载平台：{obj.platform_name}", OutputType.SUCCESS)
-                            platforms[obj.platform_name] = obj
+                                PrettyOutput.print(f"Load platform from {os.path.join(directory, filename)}: {obj.platform_name}", OutputType.SUCCESS) # type: ignore
+                            platforms[obj.platform_name] = obj # type: ignore
                             break
                 except Exception as e:
-                    PrettyOutput.print(f"加载平台 {module_name} 失败: {str(e)}", OutputType.ERROR)
+                    PrettyOutput.print(f"Load platform {module_name} failed: {str(e)}", OutputType.ERROR)
         
         return platforms
 
 
     @staticmethod
     def get_global_platform_registry():
-        """获取全局平台注册器"""
+        """Get global platform registry"""
         if PlatformRegistry.global_platform_registry is None:
             PlatformRegistry.global_platform_registry = PlatformRegistry()
             
@@ -154,58 +154,57 @@ class PlatformRegistry:
         return PlatformRegistry.global_platform_registry
     
     def __init__(self):
-        """初始化平台注册器
-        """
+        """Initialize platform registry"""
         self.platforms: Dict[str, Type[BasePlatform]] = {}
 
     def get_normal_platform(self) -> BasePlatform:
         platform_name = os.environ.get("JARVIS_PLATFORM", "kimi")
         model_name = os.environ.get("JARVIS_MODEL", "kimi")
         platform = self.create_platform(platform_name)
-        platform.set_model_name(model_name)
-        return platform
+        platform.set_model_name(model_name) # type: ignore
+        return platform # type: ignore
     
     def get_codegen_platform(self) -> BasePlatform:
         platform_name = os.environ.get("JARVIS_CODEGEN_PLATFORM", os.environ.get("JARVIS_PLATFORM", "kimi"))
         model_name = os.environ.get("JARVIS_CODEGEN_MODEL", os.environ.get("JARVIS_MODEL", "kimi"))
         platform = self.create_platform(platform_name)
-        platform.set_model_name(model_name)
-        return platform
+        platform.set_model_name(model_name) # type: ignore
+        return platform # type: ignore
     
     def get_cheap_platform(self) -> BasePlatform:
         platform_name = os.environ.get("JARVIS_CHEAP_PLATFORM", os.environ.get("JARVIS_PLATFORM", "kimi"))
         model_name = os.environ.get("JARVIS_CHEAP_MODEL", os.environ.get("JARVIS_MODEL", "kimi"))
         platform = self.create_platform(platform_name)
-        platform.set_model_name(model_name)
-        return platform
+        platform.set_model_name(model_name) # type: ignore
+        return platform # type: ignore
     
     def get_thinking_platform(self) -> BasePlatform:
         platform_name = os.environ.get("JARVIS_THINKING_PLATFORM", os.environ.get("JARVIS_PLATFORM", "kimi"))
         model_name = os.environ.get("JARVIS_THINKING_MODEL", os.environ.get("JARVIS_MODEL", "kimi"))
         platform = self.create_platform(platform_name)
-        platform.set_model_name(model_name)
-        return platform
+        platform.set_model_name(model_name) # type: ignore
+        return platform # type: ignore
 
     def register_platform(self, name: str, platform_class: Type[BasePlatform]):
-        """注册平台类
+        """Register platform class
         
         Args:
-            name: 平台名称
-            model_class: 平台类
+            name: Platform name
+            model_class: Platform class
         """
         self.platforms[name] = platform_class
             
     def create_platform(self, name: str) -> Optional[BasePlatform]:
-        """创建平台实例
+        """Create platform instance
         
         Args:
-            name: 平台名称
+            name: Platform name
             
         Returns:
-            BasePlatform: 平台实例
+            BasePlatform: Platform instance
         """
         if name not in self.platforms:
-            PrettyOutput.print(f"未找到平台: {name}", OutputType.ERROR)
+            PrettyOutput.print(f"Platform not found: {name}", OutputType.ERROR)
             return None
             
         try:
@@ -213,10 +212,10 @@ class PlatformRegistry:
             platform = self.platforms[name]()
             return platform
         except Exception as e:
-            PrettyOutput.print(f"创建平台失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Create platform failed: {str(e)}", OutputType.ERROR)
             return None
             
     def get_available_platforms(self) -> List[str]:
-        """获取可用平台列表"""
+        """Get available platform list"""
         return list(self.platforms.keys()) 
     

jarvis/tools/ask_user.py

@@ -4,13 +4,13 @@ from jarvis.utils import get_multiline_input, PrettyOutput, OutputType
 
 class AskUserTool:
     name="ask_user"
-    description="""当缺少完成任务的信息或有关键决策信息缺失时，询问用户。用户可以输入多行文本，空行结束输入。使用场景：1. 需要用户提供更多信息来完成任务；2. 需要用户做出关键决策；3. 需要用户确认某些重要操作；4. 需要用户提供额外信息"""
+    description="""Ask the user when information needed to complete the task is missing or when critical decision information is lacking. Users can input multiple lines of text, ending with an empty line. Use cases: 1. Need user to provide more information to complete the task; 2. Need user to make critical decisions; 3. Need user to confirm important operations; 4. Need user to provide additional information"""
     parameters={
         "type": "object",
         "properties": {
             "question": {
                 "type": "string",
-                "description": "要询问用户的问题"
+                "description": "The question to ask the user"
             }
         },
         "required": ["question"]
@@ -34,12 +34,12 @@ class AskUserTool:
             PrettyOutput.print(question, OutputType.SYSTEM)
             
             # 获取用户输入
-            user_response = get_multiline_input("请输入您的回答（输入空行结束）")
+            user_response = get_multiline_input("Please enter your answer (input empty line to end)")
             
             if user_response == "__interrupt__":
                 return {
                     "success": False,
-                    "error": "用户取消了输入"
+                    "error": "User canceled input"
                 }
             
             return {
@@ -50,5 +50,5 @@ class AskUserTool:
         except Exception as e:
             return {
                 "success": False,
-                "error": f"询问用户失败: {str(e)}"
+                "error": f"Failed to ask user: {str(e)}"
             } 

jarvis/tools/base.py

@@ -11,7 +11,7 @@ class Tool:
         self.func = func
 
     def to_dict(self) -> Dict:
-        """转换为工具格式"""
+        """Convert to tool format"""
         return {
             "name": self.name,
             "description": self.description,
@@ -19,5 +19,5 @@ class Tool:
         }
 
     def execute(self, arguments: Dict) -> Dict[str, Any]:
-        """执行工具函数"""
+        """Execute tool function"""
         return self.func(arguments)