jarvis-ai-assistant 0.1.89__py3-none-any.whl → 0.1.91__py3-none-any.whl

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.89" 
+__version__ = "0.1.91" 

jarvis/agent.py

@@ -132,7 +132,7 @@ class Agent:
             embedding = self.embedding_model.encode([text], 
                                                  convert_to_tensor=True,
                                                  normalize_embeddings=True)
-            vector = np.array(embedding, dtype=np.float32)
+            vector = np.array(embedding.cpu().numpy(), dtype=np.float32)
             return vector[0]  # 返回第一个向量，因为我们只编码了一个文本
         except Exception as e:
             PrettyOutput.print(f"创建方法论嵌入向量失败: {str(e)}", OutputType.ERROR)
@@ -337,7 +337,7 @@ class Agent:
 
             self.model.set_system_message(f"""你是 {self.name}，一个问题处理能力强大的 AI 助手。
                                           
-你会严格按照以下步骤处理问题：
+如果用户需要执行任务，你会严格按照以下步骤处理问题：
 1. 问题重述：确认理解问题
 2. 根因分析（如果是问题分析类需要，其他不需要）
 3. 设定目标：需要可达成，可检验的一个或多个目标
@@ -388,7 +388,7 @@ arguments:
 -------------------------------------------------------------
 
 """)
-            self.prompt = f"用户任务: {user_input}"
+            self.prompt = f"{user_input}"
 
             while True:
                 try:

jarvis/jarvis_codebase/main.py

@@ -20,6 +20,7 @@ class CodeBase:
         os.chdir(self.root_dir)
         self.thread_count = get_thread_count()
         self.max_context_length = get_max_context_length()
+        self.index = None
             
         # 初始化数据目录
         self.data_dir = os.path.join(self.root_dir, ".jarvis-codebase")
@@ -473,10 +474,10 @@ class CodeBase:
     def search_similar(self, query: str, top_k: int = 30) -> List[Tuple[str, float, str]]:
         """搜索关联文件"""
         try:
+            if self.index is None:
+                return []
             # 生成多个查询变体以提高召回率
             model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
-            model.set_suppress_output(True)
-            
             prompt = f"""请根据以下查询，生成3个不同的表述，每个表述都要完整表达原始查询的意思。这些表述将用于代码搜索，要保持专业性和准确性。
 原始查询: {query}
 

jarvis/jarvis_platform/main.py

@@ -0,0 +1,121 @@
+from jarvis.models.registry import PlatformRegistry
+from jarvis.utils import PrettyOutput, OutputType, load_env_from_file, get_multiline_input
+
+def list_platforms():
+    """列出所有支持的平台和模型"""
+    registry = PlatformRegistry.get_global_platform_registry()
+    platforms = registry.get_available_platforms()
+    
+    PrettyOutput.section("支持的平台和模型", OutputType.SUCCESS)
+    
+    for platform_name in platforms:
+        # 创建平台实例
+        platform = registry.create_platform(platform_name)
+        if not platform:
+            continue
+            
+        # 获取平台支持的模型列表
+        try:
+            models = platform.get_model_list()
+            
+            # 打印平台名称
+            PrettyOutput.section(f"{platform_name}", OutputType.SUCCESS)
+            
+            # 打印模型列表
+            if models:
+                for model_name, description in models:
+                    if description:
+                        PrettyOutput.print(f"  • {model_name} - {description}", OutputType.SUCCESS)
+                    else:
+                        PrettyOutput.print(f"  • {model_name}", OutputType.SUCCESS)
+            else:
+                PrettyOutput.print("  没有可用的模型信息", OutputType.WARNING)
+                
+        except Exception as e:
+            PrettyOutput.print(f"获取 {platform_name} 平台模型列表失败: {str(e)}", OutputType.ERROR)
+
+def chat_with_model(platform_name: str, model_name: str):
+    """与指定平台和模型进行对话"""
+    registry = PlatformRegistry.get_global_platform_registry()
+    
+    # 创建平台实例
+    platform = registry.create_platform(platform_name)
+    if not platform:
+        PrettyOutput.print(f"创建平台 {platform_name} 失败", OutputType.ERROR)
+        return
+    
+    try:
+        # 设置模型
+        platform.set_model_name(model_name)
+        PrettyOutput.print(f"已连接到 {platform_name} 平台的 {model_name} 模型", OutputType.SUCCESS)
+        
+        # 开始对话循环
+        while True:
+            # 获取用户输入
+            user_input = get_multiline_input("")
+            
+            # 检查是否取消输入
+            if user_input == "__interrupt__":
+                break
+                
+            # 检查是否为空输入
+            if not user_input.strip():
+                continue
+                
+            try:
+                # 发送到模型并获取回复
+                response = platform.chat(user_input)
+                if not response:
+                    PrettyOutput.print("未获得有效回复", OutputType.WARNING)
+                    
+            except Exception as e:
+                PrettyOutput.print(f"对话失败: {str(e)}", OutputType.ERROR)
+                
+    except Exception as e:
+        PrettyOutput.print(f"初始化对话失败: {str(e)}", OutputType.ERROR)
+    finally:
+        # 清理资源
+        try:
+            platform.delete_chat()
+        except:
+            pass
+
+def info_command(args):
+    """处理 info 子命令"""
+    list_platforms()
+
+def chat_command(args):
+    """处理 chat 子命令"""
+    if not args.platform or not args.model:
+        PrettyOutput.print("请指定平台和模型。使用 'jarvis info' 查看可用的平台和模型。", OutputType.ERROR)
+        return
+    chat_with_model(args.platform, args.model)
+
+def main():
+    """主函数"""
+    import argparse
+
+    load_env_from_file()
+    
+    parser = argparse.ArgumentParser(description='Jarvis AI Platform')
+    subparsers = parser.add_subparsers(dest='command', help='可用的子命令')
+    
+    # info 子命令
+    info_parser = subparsers.add_parser('info', help='显示支持的平台和模型信息')
+    
+    # chat 子命令
+    chat_parser = subparsers.add_parser('chat', help='与指定的平台和模型进行对话')
+    chat_parser.add_argument('--platform', '-p', help='指定要使用的平台')
+    chat_parser.add_argument('--model', '-m', help='指定要使用的模型')
+    
+    args = parser.parse_args()
+    
+    if args.command == 'info':
+        info_command(args)
+    elif args.command == 'chat':
+        chat_command(args)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

jarvis/jarvis_rag/main.py

@@ -144,6 +144,7 @@ class RAGTool:
         self.min_paragraph_length = int(os.environ.get("JARVIS_MIN_PARAGRAPH_LENGTH", "50"))  # 最小段落长度
         self.max_paragraph_length = int(os.environ.get("JARVIS_MAX_PARAGRAPH_LENGTH", "1000"))  # 最大段落长度
         self.context_window = int(os.environ.get("JARVIS_CONTEXT_WINDOW", "5"))  # 上下文窗口大小，默认前后各5个片段
+        self.max_context_length = int(get_max_context_length() * 0.8)
         
         # 初始化数据目录
         self.data_dir = os.path.join(self.root_dir, ".jarvis-rag")
@@ -163,7 +164,6 @@ class RAGTool:
         self.cache_path = os.path.join(self.data_dir, "cache.pkl")
         self.documents: List[Document] = []
         self.index = None
-        self.max_context_length = get_max_context_length()
         
         # 加载缓存
         self._load_cache()
@@ -400,7 +400,7 @@ class RAGTool:
         PrettyOutput.print(f"成功索引了 {len(self.documents)} 个文档片段", 
                         output_type=OutputType.SUCCESS)
 
-    def search(self, query: str, top_k: int = 5) -> List[Tuple[Document, float]]:
+    def search(self, query: str, top_k: int = 30) -> List[Tuple[Document, float]]:
         """优化搜索策略"""
         if not self.index:
             PrettyOutput.print("索引未构建，正在构建...", output_type=OutputType.INFO)
@@ -557,27 +557,55 @@ class RAGTool:
             results = self.query(question)
             if not results:
                 return None
+            
+            # 显示找到的文档片段
+            for doc in results:
+                PrettyOutput.print(f"文件: {doc.metadata['file_path']}", output_type=OutputType.INFO)
+                PrettyOutput.print(f"片段 {doc.metadata['chunk_index'] + 1}/{doc.metadata['total_chunks']}", 
+                                output_type=OutputType.INFO)
+                PrettyOutput.print("\n内容:", output_type=OutputType.INFO)
+                content = doc.content.encode('utf-8', errors='replace').decode('utf-8')
+                PrettyOutput.print(content, output_type=OutputType.INFO)
+
+            # 构建基础提示词
+            base_prompt = f"""请基于以下文档片段回答用户的问题。如果文档内容不足以完整回答问题，请明确指出。
+
+用户问题: {question}
 
-            # 构建上下文
+相关文档片段:
+"""
+            end_prompt = "\n请提供准确、简洁的回答，如果文档内容不足以完整回答问题，请明确指出。"
+            
+            # 计算可用于文档内容的最大长度
+            # 预留一些空间给模型回答
+            available_length = self.max_context_length - len(base_prompt) - len(end_prompt) - 500
+            
+            # 构建上下文，同时控制总长度
             context = []
+            current_length = 0
+            
             for doc in results:
-                context.append(f"""
+                # 计算这个文档片段的内容长度
+                doc_content = f"""
 来源文件: {doc.metadata['file_path']}
 内容:
 {doc.content}
 ---
-""")
+"""
+                content_length = len(doc_content)
+                
+                # 如果添加这个片段会超出限制，就停止添加
+                if current_length + content_length > available_length:
+                    PrettyOutput.print("由于上下文长度限制，部分相关文档片段被省略", 
+                                    output_type=OutputType.WARNING)
+                    break
+                    
+                context.append(doc_content)
+                current_length += content_length
 
-            # 构建提示词
-            prompt = f"""请基于以下文档片段回答用户的问题。如果文档内容不足以完整回答问题，请明确指出。
+            # 构建完整的提示词
+            prompt = base_prompt + ''.join(context) + end_prompt
             
-用户问题: {question}
-
-相关文档片段:
-{''.join(context)}
-
-请提供准确、简洁的回答，并在适当时引用具体的文档来源。
-"""
             # 获取模型实例并生成回答
             model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
             response = model.chat(prompt)

jarvis/jarvis_smart_shell/main.py

@@ -55,12 +55,6 @@ def process_request(request: str) -> Optional[str]:
 4. 不要添加任何换行或额外空格
 5. 如果需要多个命令，使用 && 连接
 
-安全要求：
-- 生成的命令必须是安全的，不能包含危险操作
-- 如果需要sudo权限，要明确提示用户
-- 对于复杂操作，优先使用管道而不是临时文件
-- 确保命令的可移植性，优先使用通用的POSIX命令
-
 示例输入：
 "查找当前目录下的所有Python文件"
 

jarvis/models/ai8.py

@@ -1,5 +1,5 @@
 import os
-from typing import Dict, List
+from typing import Dict, List, Tuple
 from jarvis.models.base import BasePlatform
 from jarvis.utils import PrettyOutput, OutputType
 import requests
@@ -12,7 +12,9 @@ class AI8Model(BasePlatform):
     platform_name = "ai8"
     BASE_URL = "https://ai8.rcouyi.com"
 
-    first_time = True
+    def get_model_list(self) -> List[Tuple[str, str]]:
+        """获取模型列表"""
+        return [(name,info['desc']) for name,info in self.models.items()]
     
     def __init__(self):
         """Initialize model"""
@@ -22,53 +24,13 @@ class AI8Model(BasePlatform):
         self.files = []
         self.models = {}  # 存储模型信息
 
-        # 获取可用模型列表
-        available_models = self.get_available_models()
-        
-        if AI8Model.first_time:
-            AI8Model.first_time = False
-            if available_models:
-                PrettyOutput.section("支持的模型", OutputType.SUCCESS)
-                for model in self.models.values():
-                    # 格式化显示模型信息
-                    model_str = f"{model['value']:<30}"
-                    
-                    # 添加标签
-                    model_str += f"{model['label']}"
-                    
-                    # 添加标签和积分信息
-                    attrs = []
-                    if model['attr'].get('tag'):
-                        attrs.append(model['attr']['tag'])
-                    if model['attr'].get('integral'):
-                        attrs.append(model['attr']['integral'])
-                        
-                    # 添加特性标记
-                    features = []
-                    if model['attr'].get('multimodal'):
-                        features.append("多模态")
-                    if model['attr'].get('plugin'):
-                        features.append("插件支持")
-                    if model['attr'].get('onlyImg'):
-                        features.append("图像支持")
-                    if features:
-                        model_str += f" [{'|'.join(features)}]"
-                        
-                    # 添加备注
-                    if model['attr'].get('note'):
-                        model_str += f" - {model['attr']['note']}"
-                        
-                    PrettyOutput.print(model_str, OutputType.INFO)
-            else:
-                PrettyOutput.print("获取模型列表失败", OutputType.WARNING)
-
         self.token = os.getenv("AI8_API_KEY")
         if not self.token:
-            raise Exception("AI8_API_KEY is not set")
+            PrettyOutput.print("AI8_API_KEY未设置", OutputType.WARNING)
         
         
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
-        if self.model_name not in self.models:
+        if self.model_name not in self.get_available_models():
             PrettyOutput.print(f"警告: 当前选择的模型 {self.model_name} 不在可用列表中", OutputType.WARNING)
         
 
@@ -283,6 +245,9 @@ class AI8Model(BasePlatform):
             List[str]: 可用模型名称列表
         """
         try:
+            if self.models:
+                return list(self.models.keys())
+            
             headers = {
                 'Content-Type': 'application/json',
                 'Accept': 'application/json, text/plain, */*',
@@ -311,6 +276,33 @@ class AI8Model(BasePlatform):
                 model['value']: model 
                 for model in data['data']['models']
             }
+
+            for model in self.models.values():
+                # 添加标签
+                model_str = f"{model['label']}"
+                
+                # 添加标签和积分信息
+                attrs = []
+                if model['attr'].get('tag'):
+                    attrs.append(model['attr']['tag'])
+                if model['attr'].get('integral'):
+                    attrs.append(model['attr']['integral'])
+                    
+                # 添加特性标记
+                features = []
+                if model['attr'].get('multimodal'):
+                    features.append("多模态")
+                if model['attr'].get('plugin'):
+                    features.append("插件支持")
+                if model['attr'].get('onlyImg'):
+                    features.append("图像支持")
+                if features:
+                    model_str += f" [{'|'.join(features)}]"
+                    
+                # 添加备注
+                if model['attr'].get('note'):
+                    model_str += f" - {model['attr']['note']}"
+                model['desc'] = model_str
             
             return list(self.models.keys())
             

jarvis/models/base.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Dict, List
+from typing import Dict, List, Tuple
 
 
 class BasePlatform(ABC):
@@ -14,6 +14,7 @@ class BasePlatform(ABC):
         """销毁模型"""
         self.delete_chat()
 
+    @abstractmethod
     def set_model_name(self, model_name: str):
         """设置模型名称"""
         raise NotImplementedError("set_model_name is not implemented")
@@ -23,10 +24,12 @@ class BasePlatform(ABC):
         """执行对话"""
         raise NotImplementedError("chat is not implemented")
 
+    @abstractmethod
     def upload_files(self, file_list: List[str]) -> List[Dict]:
         """上传文件"""
         raise NotImplementedError("upload_files is not implemented")
 
+    @abstractmethod
     def reset(self):
         """重置模型"""
         raise NotImplementedError("reset is not implemented")
@@ -41,9 +44,15 @@ class BasePlatform(ABC):
         """删除对话"""
         raise NotImplementedError("delete_chat is not implemented")
     
+    @abstractmethod
     def set_system_message(self, message: str):
         """设置系统消息"""
         raise NotImplementedError("set_system_message is not implemented")
+    
+    @abstractmethod
+    def get_model_list(self) -> List[Tuple[str, str]]:
+        """获取模型列表"""
+        raise NotImplementedError("get_model_list is not implemented")
 
     def set_suppress_output(self, suppress: bool):
         """设置是否屏蔽输出"""

jarvis/models/kimi.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, List, Tuple
 import requests
 import json
 import os
@@ -12,12 +12,17 @@ class KimiModel(BasePlatform):
     """Kimi模型实现"""
 
     platform_name = "kimi"
+
+    def get_model_list(self) -> List[Tuple[str, str]]:
+        """获取模型列表"""
+        return [("kimi", "基于网页Kimi的封装，免费接口")]
     
     def __init__(self):
         """
         初始化Kimi模型
         """
         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)
@@ -35,7 +40,7 @@ class KimiModel(BasePlatform):
             PrettyOutput.print("\n   方法 2: 直接设置环境变量:", OutputType.INFO)
             PrettyOutput.print("   export KIMI_API_KEY=your_key_here", OutputType.INFO)
             PrettyOutput.print("\n设置完成后重新运行 Jarvis。", OutputType.INFO)
-            raise Exception("KIMI_API_KEY is not set")
+            PrettyOutput.print("KIMI_API_KEY未设置", OutputType.WARNING)
         self.auth_header = f"Bearer {self.api_key}"
         self.chat_id = ""
         self.uploaded_files = []  # 存储已上传文件的信息

jarvis/models/ollama.py

@@ -1,5 +1,5 @@
 import requests
-from typing import List, Dict
+from typing import List, Dict, Tuple
 from jarvis.models.base import BasePlatform
 from jarvis.utils import OutputType, PrettyOutput
 import os
@@ -20,7 +20,6 @@ class OllamaPlatform(BasePlatform):
         
         # 检查 Ollama 服务是否可用
         try:
-            PrettyOutput.print(f"正在连接 Ollama 服务 ({self.api_base})...", OutputType.INFO)
             response = requests.get(f"{self.api_base}/api/tags")
             response.raise_for_status()
             available_models = [model["name"] for model in response.json().get("models", [])]
@@ -32,16 +31,6 @@ class OllamaPlatform(BasePlatform):
                 PrettyOutput.print(f"   ollama pull {self.model_name}", OutputType.INFO)
                 raise Exception("No available models found")
                 
-            PrettyOutput.print(f"可用模型: {', '.join(available_models)}", OutputType.INFO)
-            
-            if self.model_name not in available_models:
-                PrettyOutput.print(f"\n警告：模型 {self.model_name} 未下载", OutputType.WARNING)
-                PrettyOutput.print("\n请使用以下命令下载模型：", OutputType.INFO)
-                PrettyOutput.print(f"ollama pull {self.model_name}", OutputType.INFO)
-                raise Exception(f"Model {self.model_name} is not available")
-                
-            PrettyOutput.print(f"使用模型: {self.model_name}", OutputType.SUCCESS)
-                
         except requests.exceptions.ConnectionError:
             PrettyOutput.print("\nOllama 服务未启动或无法连接", OutputType.ERROR)
             PrettyOutput.print("请确保已经：", OutputType.INFO)
@@ -53,6 +42,12 @@ class OllamaPlatform(BasePlatform):
         self.messages = []
         self.system_message = ""
 
+    def get_model_list(self) -> List[Tuple[str, str]]:
+        """获取模型列表"""
+        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):
         """设置模型名称"""
         self.model_name = model_name

jarvis/models/openai.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, List, Tuple
 import os
 from openai import OpenAI
 from jarvis.models.base import BasePlatform
@@ -8,17 +8,22 @@ class OpenAIModel(BasePlatform):
     """DeepSeek模型实现"""
 
     platform_name = "openai"
+
+    def upload_files(self, file_list: List[str]):
+        """上传文件"""
+        PrettyOutput.print("OpenAI 不支持上传文件", OutputType.WARNING)
     
     def __init__(self):
         """
         初始化DeepSeek模型
         """
         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.deepseek.com", 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("   OPENAI_API_KEY=your_api_key", OutputType.INFO)
@@ -28,7 +33,7 @@ class OpenAIModel(BasePlatform):
             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)
-            raise Exception("OPENAI_API_KEY is not set")
+            PrettyOutput.print("OPENAI_API_KEY未设置", 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"
@@ -41,6 +46,10 @@ class OpenAIModel(BasePlatform):
         self.messages: List[Dict[str, str]] = []
         self.system_message = ""
 
+    def get_model_list(self) -> List[Tuple[str, str]]:
+        """获取模型列表"""
+        return []
+
     def set_model_name(self, model_name: str):
         """设置模型名称"""
 

jarvis/models/oyi.py

@@ -1,6 +1,6 @@
 import mimetypes
 import os
-from typing import Dict, List
+from typing import Dict, List, Tuple
 from jarvis.models.base import BasePlatform
 from jarvis.utils import PrettyOutput, OutputType, get_max_context_length
 import requests
@@ -12,36 +12,26 @@ class OyiModel(BasePlatform):
     platform_name = "oyi"
     BASE_URL = "https://api-10086.rcouyi.com"
 
-    first_time = True
+    def get_model_list(self) -> List[Tuple[str, str]]:
+        """获取模型列表"""
+        return [(name,info['desc']) for name,info in self.models.items()]
     
     def __init__(self):
         """Initialize model"""
         super().__init__()
-        PrettyOutput.section("支持的模型", OutputType.SUCCESS)
-        
-        # 获取可用模型列表
-        available_models = self.get_available_models()
-
-        if OyiModel.first_time:
-            OyiModel.first_time = False
-            if available_models:
-                for model in available_models:
-                    PrettyOutput.print(model, OutputType.INFO)
-            else:
-                PrettyOutput.print("获取模型列表失败", OutputType.WARNING)
-        
+        self.models = {}        
         self.messages = []
         self.system_message = ""
         self.conversation = None
-        self.upload_files = []  # 重命名 files 为 upload_files
+        self.upload_files = [] 
         self.first_chat = True
         
         self.token = os.getenv("OYI_API_KEY")
         if not self.token:
-            raise Exception("OYI_API_KEY is not set")
+            PrettyOutput.print("OYI_API_KEY未设置", OutputType.WARNING)
         
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
-        if self.model_name not in [m.split()[0] for m in available_models]:
+        if self.model_name not in [m.split()[0] for m in self.get_available_models()]:
             PrettyOutput.print(f"警告: 当前选择的模型 {self.model_name} 不在可用列表中", OutputType.WARNING)
         
 
@@ -313,6 +303,9 @@ class OyiModel(BasePlatform):
             List[str]: 可用模型名称列表
         """
         try:
+            if self.models:
+                return list(self.models.keys())
+            
             headers = {
                 'Content-Type': 'application/json',
                 'Accept': 'application/json, text/plain, */*',
@@ -343,7 +336,8 @@ class OyiModel(BasePlatform):
             models = []
             for model in self.models.values():
                 # 基本信息
-                model_str = f"{model['value']:<30} {model['label']}"
+                model_name = model['value']
+                model_str = model['label']
                 
                 # 添加后缀标签
                 suffix = model.get('suffix', [])
@@ -364,8 +358,8 @@ class OyiModel(BasePlatform):
                 # 添加文件上传支持标记
                 if model.get('uploadFile'):
                     model_str += " [支持文件上传]"
-                    
-                models.append(model_str)
+                model['desc'] = model_str
+                models.append(model_name)
                 
             return sorted(models)