jarvis-ai-assistant 0.7.8__py3-none-any.whl → 1.0.2__py3-none-any.whl

jarvis/jarvis_platform/kimi.py

@@ -5,10 +5,17 @@ import json
 import mimetypes
 import os
 import time
-from typing import Dict, Generator, List, Tuple
+from typing import Any
+from typing import Dict
+from typing import Generator
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import cast
 
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_utils import http
+from jarvis.jarvis_utils.output import PrettyOutput
 from jarvis.jarvis_utils.utils import while_success
 
 
@@ -28,17 +35,23 @@ class KimiModel(BasePlatform):
             ("k2", "基于网页的 Kimi，深度思考模型 K2"),
         ]
 
-    def __init__(self):
+    def __init__(self, llm_config: Optional[Dict[str, Any]] = None):
         """
         Initialize Kimi model
+
+        参数:
+            llm_config: LLM配置字典，包含 kimi_api_key 等
         """
         super().__init__()
         self.chat_id = ""  # 当前会话ID
-        self.api_key = os.getenv("KIMI_API_KEY")  # 从环境变量获取API密钥
+        llm_config = llm_config or {}
+
+        # 从 llm_config 获取配置，如果没有则从环境变量获取（向后兼容）
+        self.api_key = llm_config.get("kimi_api_key") or os.getenv("KIMI_API_KEY")
         if not self.api_key:
-            print("⚠️ KIMI_API_KEY 未设置")
+            PrettyOutput.auto_print("⚠️ KIMI_API_KEY 未设置")
         self.auth_header = f"Bearer {self.api_key}"  # 认证头信息
-        self.uploaded_files = []  # 存储已上传文件的信息
+        self.uploaded_files: List[Dict[str, Any]] = []  # 存储已上传文件的信息
         self.chat_id = ""  # 当前会话ID
         self.first_chat = True  # 标记是否是第一次对话
         self.system_message = ""  # 系统提示消息
@@ -67,12 +80,12 @@ class KimiModel(BasePlatform):
                 lambda: http.post(url, headers=headers, data=payload)
             )
             if response.status_code != 200:
-                print(f"❌ 错误：创建会话失败：{response.json()}")
+                PrettyOutput.auto_print(f"❌ 错误：创建会话失败：{response.json()}")
                 return False
-            self.chat_id = response.json()["id"]
+            self.chat_id = cast(str, cast(Dict[str, Any], response.json())["id"])
             return True
         except Exception as e:
-            print(f"❌ 错误：创建会话失败：{e}")
+            PrettyOutput.auto_print(f"❌ 错误：创建会话失败：{e}")
             return False
 
     def _get_presigned_url(self, filename: str, action: str) -> Dict:
@@ -88,9 +101,8 @@ class KimiModel(BasePlatform):
             "Content-Type": "application/json",
         }
 
-        response = while_success(
-            lambda: http.post(url, headers=headers, data=payload)        )
-        return response.json()
+        response = while_success(lambda: http.post(url, headers=headers, data=payload))
+        return cast(Dict[str, Any], response.json())
 
     def support_upload_files(self) -> bool:
         """Check if platform supports upload files"""
@@ -101,12 +113,10 @@ class KimiModel(BasePlatform):
         try:
             with open(file_path, "rb") as f:
                 content = f.read()
-                response = while_success(
-                    lambda: http.put(presigned_url, data=content)
-                )
-                return response.status_code == 200
+                response = while_success(lambda: http.put(presigned_url, data=content))
+                return bool(response.status_code == 200)
         except Exception as e:
-            print(f"❌ 错误：上传文件失败：{e}")
+            PrettyOutput.auto_print(f"❌ 错误：上传文件失败：{e}")
             return False
 
     def _get_file_info(self, file_data: Dict, name: str, file_type: str) -> Dict:
@@ -128,9 +138,8 @@ class KimiModel(BasePlatform):
             "Content-Type": "application/json",
         }
 
-        response = while_success(
-            lambda: http.post(url, headers=headers, data=payload)        )
-        return response.json()
+        response = while_success(lambda: http.post(url, headers=headers, data=payload))
+        return cast(Dict[str, Any], response.json())
 
     def _wait_for_parse(self, file_id: str) -> bool:
         """Wait for file parsing to complete"""
@@ -178,11 +187,11 @@ class KimiModel(BasePlatform):
             return True
 
         if not self.chat_id:
-            print("ℹ️ 正在创建聊天会话...")
+            PrettyOutput.auto_print("ℹ️ 正在创建聊天会话...")
             if not self._create_chat():
-                print("❌ 创建聊天会话失败")
+                PrettyOutput.auto_print("❌ 创建聊天会话失败")
                 return False
-            print("✅ 创建聊天会话成功")
+            PrettyOutput.auto_print("✅ 创建聊天会话成功")
 
         uploaded_files = []
         for index, file_path in enumerate(file_list, 1):
@@ -213,26 +222,26 @@ class KimiModel(BasePlatform):
                             log_lines.append(f"文件处理完成: {file_name}")
                         else:
                             log_lines.append(f"文件解析失败: {file_name}")
-                            joined_logs = '\n'.join(log_lines)
-                            print(f"❌ {joined_logs}")
+                            joined_logs = "\n".join(log_lines)
+                            PrettyOutput.auto_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}")
-                    joined_logs = '\n'.join(log_lines)
-                    print(f"❌ {joined_logs}")
+                    joined_logs = "\n".join(log_lines)
+                    PrettyOutput.auto_print(f"❌ {joined_logs}")
                     return False
 
                 # 成功路径统一输出本文件的处理日志
-                joined_logs = '\n'.join(log_lines)
-                print(f"ℹ️ {joined_logs}")
+                joined_logs = "\n".join(log_lines)
+                PrettyOutput.auto_print(f"ℹ️ {joined_logs}")
 
             except Exception as e:
                 log_lines.append(f"处理文件出错 {file_path}: {str(e)}")
-                joined_logs = '\n'.join(log_lines)
-                print(f"❌ {joined_logs}")
+                joined_logs = "\n".join(log_lines)
+                PrettyOutput.auto_print(f"❌ {joined_logs}")
                 return False
 
         self.uploaded_files = uploaded_files
@@ -322,25 +331,23 @@ class KimiModel(BasePlatform):
         }
 
         try:
-            response = while_success(
-                lambda: http.delete(url, headers=headers)
-            )
+            response = while_success(lambda: http.delete(url, headers=headers))
             if response.status_code == 200:
                 self.chat_id = ""
                 self.uploaded_files = []
                 self.first_chat = True  # 重置first_chat标记
                 return True
             else:
-                print(f"⚠️ 删除会话失败: HTTP {response.status_code}")
+                PrettyOutput.auto_print(f"⚠️ 删除会话失败: HTTP {response.status_code}")
                 return False
         except Exception as e:
-            print(f"❌ 删除会话时发生错误: {str(e)}")
+            PrettyOutput.auto_print(f"❌ 删除会话时发生错误: {str(e)}")
             return False
 
     def save(self, file_path: str) -> bool:
         """Save chat session to a file."""
         if not self.chat_id:
-            print("⚠️ 没有活动的会话可供保存")
+            PrettyOutput.auto_print("⚠️ 没有活动的会话可供保存")
             return False
 
         state = {
@@ -355,10 +362,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
-            print(f"✅ 会话已成功保存到 {file_path}")
+            PrettyOutput.auto_print(f"✅ 会话已成功保存到 {file_path}")
             return True
         except Exception as e:
-            print(f"❌ 保存会话失败: {str(e)}")
+            PrettyOutput.auto_print(f"❌ 保存会话失败: {str(e)}")
             return False
 
     def restore(self, file_path: str) -> bool:
@@ -374,13 +381,13 @@ class KimiModel(BasePlatform):
             self.uploaded_files = state.get("uploaded_files", [])
             self._saved = True
 
-            print(f"✅ 从 {file_path} 成功恢复会话")
+            PrettyOutput.auto_print(f"✅ 从 {file_path} 成功恢复会话")
             return True
         except FileNotFoundError:
-            print(f"❌ 会话文件未找到: {file_path}")
+            PrettyOutput.auto_print(f"❌ 会话文件未找到: {file_path}")
             return False
         except Exception as e:
-            print(f"❌ 恢复会话失败: {str(e)}")
+            PrettyOutput.auto_print(f"❌ 恢复会话失败: {str(e)}")
             return False
 
     def name(self) -> str:
@@ -399,20 +406,20 @@ class KimiModel(BasePlatform):
     @classmethod
     def get_required_env_keys(cls) -> List[str]:
         """
-        获取Kimi平台所需的环境变量键列表
+        获取Kimi平台所需的配置键列表（已弃用：建议使用 llm_config 配置）
 
         返回:
-            List[str]: 环境变量键的列表
+            List[str]: 配置键的列表（对应 llm_config 中的 kimi_api_key）
         """
         return ["KIMI_API_KEY"]
 
     @classmethod
     def get_env_config_guide(cls) -> Dict[str, str]:
         """
-        获取环境变量配置指导
+        获取配置指导（已弃用：建议使用 llm_config 配置）
 
         返回:
-            Dict[str, str]: 环境变量名到配置指导的映射
+            Dict[str, str]: 配置键名到配置指导的映射
         """
         return {
             "KIMI_API_KEY": (

jarvis/jarvis_platform/openai.py

@@ -1,55 +1,90 @@
 # -*- coding: utf-8 -*-
 import json
 import os
-from typing import Dict, Generator, List, Tuple
+from typing import Any
+from typing import Dict
+from typing import Generator
+from typing import List
+from typing import Optional
+from typing import Tuple
 
 from openai import OpenAI
+from openai.types.chat import ChatCompletionMessageParam
 
 from jarvis.jarvis_platform.base import BasePlatform
+from jarvis.jarvis_utils.output import PrettyOutput
 
 
 class OpenAIModel(BasePlatform):
-
-    def __init__(self):
+    def __init__(self, llm_config: Optional[Dict[str, Any]] = None):
         """
         Initialize OpenAI model
+
+        参数:
+            llm_config: LLM配置字典，包含 openai_api_key, openai_api_base, openai_extra_headers 等
         """
         super().__init__()
         self.system_message = ""
-        self.api_key = os.getenv("OPENAI_API_KEY")
-        if not self.api_key:
-            print("⚠️ OPENAI_API_KEY 未设置")
+        llm_config = llm_config or {}
 
-        self.base_url = os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1")
-        self.model_name = os.getenv("JARVIS_MODEL") or "gpt-4o"
+        # 从 llm_config 获取配置，如果没有则从环境变量获取（向后兼容）
+        self.api_key = llm_config.get("openai_api_key") or os.getenv("OPENAI_API_KEY")
+        if not self.api_key:
+            PrettyOutput.auto_print("⚠️ OPENAI_API_KEY 未设置")
+
+        self.base_url = llm_config.get("openai_api_base") or os.getenv(
+            "OPENAI_API_BASE", "https://api.openai.com/v1"
+        )
+        self.model_name = os.getenv("model") or "gpt-4o"
+
+        # Optional: Inject extra HTTP headers via llm_config or environment variable
+        # Expected format: openai_extra_headers='{"Header-Name": "value", "X-Trace": "abc"}'
+        headers_value = llm_config.get("openai_extra_headers")
+        if headers_value is None:
+            headers_str = os.getenv("OPENAI_EXTRA_HEADERS")
+        else:
+            headers_str = (
+                headers_value
+                if isinstance(headers_value, str)
+                else json.dumps(headers_value)
+            )
 
-                # 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)
+                parsed = (
+                    json.loads(headers_str)
+                    if isinstance(headers_str, str)
+                    else 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'}")
+                    PrettyOutput.auto_print(
+                        "⚠️ openai_extra_headers 应为 JSON 对象，如 {'X-Source':'jarvis'}"
+                    )
             except Exception as e:
-                print(f"⚠️ 解析 OPENAI_EXTRA_HEADERS 失败: {e}")
+                PrettyOutput.auto_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)
+                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]] = []
+                PrettyOutput.auto_print(
+                    "⚠️ 当前 OpenAI SDK 不支持 default_headers，未能注入额外 HTTP 头"
+                )
+        self.messages: List[ChatCompletionMessageParam] = []
         self.system_message = ""
 
     def upload_files(self, file_list: List[str]) -> bool:
@@ -81,7 +116,7 @@ class OpenAIModel(BasePlatform):
                 model_list.append((model.id, model.id))
             return model_list
         except Exception as e:
-            print(f"❌ 获取模型列表失败：{str(e)}")
+            PrettyOutput.auto_print(f"❌ 获取模型列表失败：{str(e)}")
             return []
 
     def set_model_name(self, model_name: str):
@@ -126,26 +161,26 @@ class OpenAIModel(BasePlatform):
 
             # 累计完整响应
             accumulated_response = ""
-            
+
             # 循环处理，直到不是因为长度限制而结束
             while True:
                 response = self.client.chat.completions.create(
                     model=self.model_name,  # Use the configured model name
-                    messages=self.messages,  # type: ignore
+                    messages=self.messages,
                     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
@@ -158,11 +193,20 @@ class OpenAIModel(BasePlatform):
                     # 将已获取的内容追加到消息历史中，以便下次请求时模型知道已生成的内容
                     if self.messages and self.messages[-1].get("role") == "assistant":
                         # 追加到现有的 assistant 消息
-                        self.messages[-1]["content"] += full_response
+                        last_content = self.messages[-1]["content"]
+                        if isinstance(last_content, str):
+                            self.messages[-1]["content"] = last_content + full_response
+                        else:
+                            # 如果content不是字符串，创建新的消息
+                            self.messages.append(
+                                {"role": "assistant", "content": full_response}
+                            )
                     else:
                         # 创建新的 assistant 消息
-                        self.messages.append({"role": "assistant", "content": full_response})
-                    
+                        self.messages.append(
+                            {"role": "assistant", "content": full_response}
+                        )
+
                     # 添加一个继续请求的用户消息，让模型继续生成
                     self.messages.append({"role": "user", "content": "请继续。"})
                     # 继续循环，获取剩余内容
@@ -171,18 +215,35 @@ class OpenAIModel(BasePlatform):
                     # 正常结束（stop、null 或其他原因）
                     # 将完整响应添加到消息历史
                     if accumulated_response:
-                        if self.messages and self.messages[-1].get("role") == "assistant":
+                        if (
+                            self.messages
+                            and self.messages[-1].get("role") == "assistant"
+                        ):
                             # 如果最后一条是 assistant 消息，追加本次的内容
-                            self.messages[-1]["content"] += full_response
+                            last_content = self.messages[-1]["content"]
+                            if isinstance(last_content, str):
+                                self.messages[-1]["content"] = (
+                                    last_content + full_response
+                                )
+                            else:
+                                # 如果content不是字符串，创建新的消息
+                                self.messages.append(
+                                    {
+                                        "role": "assistant",
+                                        "content": accumulated_response,
+                                    }
+                                )
                         else:
                             # 创建新的 assistant 消息，使用累计的完整响应
-                            self.messages.append({"role": "assistant", "content": accumulated_response})
+                            self.messages.append(
+                                {"role": "assistant", "content": accumulated_response}
+                            )
                     break
 
             return None
 
         except Exception as e:
-            print(f"❌ 对话失败：{str(e)}")
+            PrettyOutput.auto_print(f"❌ 对话失败：{str(e)}")
             raise Exception(f"Chat failed: {str(e)}")
 
     def name(self) -> str:
@@ -231,10 +292,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
-            print(f"✅ 会话已成功保存到 {file_path}")
+            PrettyOutput.auto_print(f"✅ 会话已成功保存到 {file_path}")
             return True
         except Exception as e:
-            print(f"❌ 保存会话失败: {str(e)}")
+            PrettyOutput.auto_print(f"❌ 保存会话失败: {str(e)}")
             return False
 
     def restore(self, file_path: str) -> bool:
@@ -248,13 +309,13 @@ class OpenAIModel(BasePlatform):
             # atexit.register(self.delete_chat)
             self._saved = True
 
-            print(f"✅ 从 {file_path} 成功恢复会话")
+            PrettyOutput.auto_print(f"✅ 从 {file_path} 成功恢复会话")
             return True
         except FileNotFoundError:
-            print(f"❌ 会话文件未找到: {file_path}")
+            PrettyOutput.auto_print(f"❌ 会话文件未找到: {file_path}")
             return False
         except Exception as e:
-            print(f"❌ 恢复会话失败: {str(e)}")
+            PrettyOutput.auto_print(f"❌ 恢复会话失败: {str(e)}")
             return False
 
     def support_web(self) -> bool:
@@ -278,20 +339,20 @@ class OpenAIModel(BasePlatform):
     @classmethod
     def get_required_env_keys(cls) -> List[str]:
         """
-        获取OpenAI平台所需的环境变量键列表
+        获取OpenAI平台所需的配置键列表（已弃用：建议使用 llm_config 配置）
 
         返回:
-            List[str]: 环境变量键的列表
+            List[str]: 配置键的列表（对应 llm_config 中的 openai_api_key, openai_api_base）
         """
         return ["OPENAI_API_KEY", "OPENAI_API_BASE"]
 
     @classmethod
     def get_env_config_guide(cls) -> Dict[str, str]:
         """
-        获取环境变量配置指导
+        获取配置指导（已弃用：建议使用 llm_config 配置）
 
         返回:
-            Dict[str, str]: 环境变量名到配置指导的映射
+            Dict[str, str]: 配置键名到配置指导的映射
         """
         return {
             "OPENAI_API_KEY": (

jarvis/jarvis_platform/registry.py

@@ -3,18 +3,22 @@ import importlib
 import inspect
 import os
 import sys
-from typing import Dict, List, Optional, Type
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import 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.config import get_cheap_model_name
+from jarvis.jarvis_utils.config import get_cheap_platform_name
+from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.config import get_llm_config
+from jarvis.jarvis_utils.config import get_normal_model_name
+from jarvis.jarvis_utils.config import get_normal_platform_name
+from jarvis.jarvis_utils.config import get_smart_model_name
+from jarvis.jarvis_utils.config import get_smart_platform_name
+from jarvis.jarvis_utils.output import PrettyOutput
 
 REQUIRED_METHODS = [
     ("chat", ["message"]),  # 方法名和参数列表
@@ -45,7 +49,7 @@ class PlatformRegistry:
                 ):
                     pass
             except Exception as e:
-                print(f"❌ 创建平台目录失败: {str(e)}")
+                PrettyOutput.auto_print(f"❌ 创建平台目录失败: {str(e)}")
                 return ""
         return user_platform_dir
 
@@ -80,7 +84,9 @@ class PlatformRegistry:
                 missing_methods.append(f"{method_name}(parameter mismatch)")
 
         if missing_methods:
-            print(f"⚠️ 平台 {platform_class.__name__} 缺少必要的方法: {', '.join(missing_methods)}")
+            PrettyOutput.auto_print(
+                f"⚠️ 平台 {platform_class.__name__} 缺少必要的方法: {', '.join(missing_methods)}"
+            )
             return False
 
         return True
@@ -99,7 +105,7 @@ class PlatformRegistry:
 
         # 确保目录存在
         if not os.path.exists(directory):
-            print(f"⚠️ 平台目录不存在: {directory}")
+            PrettyOutput.auto_print(f"⚠️ 平台目录不存在: {directory}")
             return platforms
 
         # 获取目录的包名
@@ -149,8 +155,8 @@ class PlatformRegistry:
                     error_lines.append(f"加载平台 {module_name} 失败: {str(e)}")
 
         if error_lines:
-            joined_errors = '\n'.join(error_lines)
-            print(f"❌ {joined_errors}")
+            joined_errors = "\n".join(error_lines)
+            PrettyOutput.auto_print(f"❌ {joined_errors}")
         return platforms
 
     @staticmethod
@@ -179,28 +185,39 @@ class PlatformRegistry:
             ) in PlatformRegistry.load_platform_from_dir(platform_dir).items():
                 self.register_platform(platform_name, platform_class)
 
-    def get_normal_platform(self) -> BasePlatform:
+    def get_normal_platform(
+        self, model_group_override: Optional[str] = None
+    ) -> BasePlatform:
         """获取正常操作的平台实例"""
-        platform_name = get_normal_platform_name()
-        model_name = get_normal_model_name()
-        platform = self.create_platform(platform_name)
+        platform_name = get_normal_platform_name(model_group_override)
+        model_name = get_normal_model_name(model_group_override)
+        llm_config = get_llm_config("normal", model_group_override)
+        platform = self.create_platform(platform_name, llm_config)
         platform.set_model_name(model_name)  # type: ignore
         return platform  # type: ignore
 
-    def get_cheap_platform(self) -> BasePlatform:
+    def get_cheap_platform(
+        self, model_group_override: Optional[str] = None
+    ) -> BasePlatform:
         """获取廉价操作的平台实例"""
-        platform_name = get_cheap_platform_name()
-        model_name = get_cheap_model_name()
-        platform = self.create_platform(platform_name)
+        platform_name = get_cheap_platform_name(model_group_override)
+        model_name = get_cheap_model_name(model_group_override)
+        llm_config = get_llm_config("cheap", model_group_override)
+        platform = self.create_platform(platform_name, llm_config)
         platform.set_model_name(model_name)  # type: ignore
+        platform.set_platform_type("cheap")  # type: ignore
         return platform  # type: ignore
 
-    def get_smart_platform(self) -> BasePlatform:
+    def get_smart_platform(
+        self, model_group_override: Optional[str] = None
+    ) -> BasePlatform:
         """获取智能操作的平台实例"""
-        platform_name = get_smart_platform_name()
-        model_name = get_smart_model_name()
-        platform = self.create_platform(platform_name)
+        platform_name = get_smart_platform_name(model_group_override)
+        model_name = get_smart_model_name(model_group_override)
+        llm_config = get_llm_config("smart", model_group_override)
+        platform = self.create_platform(platform_name, llm_config)
         platform.set_model_name(model_name)  # type: ignore
+        platform.set_platform_type("smart")  # type: ignore
         return platform  # type: ignore
 
     def register_platform(self, name: str, platform_class: Type[BasePlatform]) -> None:
@@ -212,26 +229,27 @@ class PlatformRegistry:
         """
         self.platforms[name] = platform_class
 
-    def create_platform(self, name: str) -> Optional[BasePlatform]:
-        """Create platform instance"""
+    def create_platform(
+        self, name: str, llm_config: Optional[Dict[str, Any]] = None
+    ) -> Optional[BasePlatform]:
         """Create platform instance
 
         Args:
             name: Platform name
+            llm_config: LLM配置字典，包含平台特定的配置参数（如 api_key, base_url 等）
 
         Returns:
             BasePlatform: Platform instance
         """
         if name not in self.platforms:
-            print(f"⚠️ 未找到平台: {name}")
+            PrettyOutput.auto_print(f"⚠️ 未找到平台: {name}")
             return None
 
         try:
-
-            platform = self.platforms[name]()
+            platform = self.platforms[name](llm_config=llm_config or {})
             return platform
         except Exception as e:
-            print(f"❌ 创建平台失败: {str(e)}")
+            PrettyOutput.auto_print(f"❌ 创建平台失败: {str(e)}")
             return None
 
     def get_available_platforms(self) -> List[str]: