feat(config, chat, ui): 添加思考模型及预算管理功能

引入了思考模型 (THINKING_MODELS) 和相应的预算映射 (THINKING_BUDGET_MAP) 的概念，允许在配置中指定用于特定内部处理流程（如“思考过程”）的模型及其 token 预算。

主要变更包括：

后端 (Python):
- 在 `Settings` 中添加了 `THINKING_MODELS` (List[str]) 和 `THINKING_BUDGET_MAP` (Dict[str, float]) 配置项。
- 增强了 `config._parse_db_value` 函数，以正确解析来自数据库或环境变量的列表和字典字符串（包括处理单引号和提供更详细的日志）。
- 更新了相关服务（如 `GeminiChatService`, `ModelService`, `ConfigService`）以识别和利用这些新配置。
- 调整了中间件和路由以适应可能的逻辑变更。

前端 (HTML/JavaScript):
- 在配置编辑器 (`config_editor.html`, `config_editor.js`) 中添加了新的 UI 部分来管理思考模型列表和预算映射。
- 实现了动态添加/删除思考模型的功能，并自动关联/解除关联对应的预算映射条目。
- 预算映射中的模型名称（键）是只读的，自动从思考模型列表同步；预算值（值）是可编辑的数字输入。
- 更新了表单数据的加载 (`populateForm`) 和收集 (`collectFormData`) 逻辑，以正确处理新的列表和映射类型。
- 移除了手动添加预算映射的按钮，改为自动关联。
- 改进了数组和映射项的 DOM 操作逻辑，包括使用 UUID 来关联模型和预算项。

app/config/config.py

@@ -46,6 +46,8 @@ class Settings(BaseSettings):
     TOOLS_CODE_EXECUTION_ENABLED: bool = False
     SHOW_SEARCH_LINK: bool = True
     SHOW_THINKING_PROCESS: bool = True
+    THINKING_MODELS: List[str] = [] # 新增：用于思考过程的模型列表
+    THINKING_BUDGET_MAP: Dict[str, float] = {} # 新增：模型对应的预算映射
     
     # 图像生成相关配置
     PAID_KEY: str = ""
@@ -85,25 +87,54 @@ def _parse_db_value(key: str, db_value: str, target_type: Type) -> Any:
     from app.log.logger import get_config_logger # 函数内导入
     logger = get_config_logger() # 函数内初始化
     try:
+        # 处理 List[str]
         if target_type == List[str]:
-            # 尝试解析 JSON 列表，如果失败则按逗号分割
             try:
                 parsed = json.loads(db_value)
                 if isinstance(parsed, list):
                     return [str(item) for item in parsed]
             except json.JSONDecodeError:
-                # 回退到逗号分割，去除空格
                 return [item.strip() for item in db_value.split(',') if item.strip()]
-            # 如果解析后不是列表或解析失败，返回空列表或进行其他处理
             logger.warning(f"Could not parse '{db_value}' as List[str] for key '{key}', falling back to comma split or empty list.")
-            return [item.strip() for item in db_value.split(',') if item.strip()] # Fallback
+            return [item.strip() for item in db_value.split(',') if item.strip()]
+        # 处理 Dict[str, float]
+        elif target_type == Dict[str, float]:
+            parsed_dict = {}
+            try:
+                # First attempt: standard JSON parsing
+                parsed = json.loads(db_value)
+                if isinstance(parsed, dict):
+                    parsed_dict = {str(k): float(v) for k, v in parsed.items()}
+                else:
+                     logger.warning(f"Parsed DB value for key '{key}' is not a dictionary type. Value: {db_value}")
+            except (json.JSONDecodeError, ValueError, TypeError) as e1:
+                # Second attempt: try replacing single quotes if JSONDecodeError occurred
+                if isinstance(e1, json.JSONDecodeError) and "'" in db_value:
+                    logger.warning(f"Failed initial JSON parse for key '{key}'. Attempting to replace single quotes. Error: {e1}")
+                    try:
+                        corrected_db_value = db_value.replace("'", '"')
+                        parsed = json.loads(corrected_db_value)
+                        if isinstance(parsed, dict):
+                             parsed_dict = {str(k): float(v) for k, v in parsed.items()}
+                        else:
+                            logger.warning(f"Parsed DB value (after quote replacement) for key '{key}' is not a dictionary type. Value: {corrected_db_value}")
+                    except (json.JSONDecodeError, ValueError, TypeError) as e2:
+                         logger.error(f"Could not parse '{db_value}' as Dict[str, float] for key '{key}' even after replacing quotes: {e2}. Returning empty dict.")
+                else:
+                    # Log other errors (ValueError, TypeError) or JSON errors without single quotes
+                    logger.error(f"Could not parse '{db_value}' as Dict[str, float] for key '{key}': {e1}. Returning empty dict.")
+            return parsed_dict # Return the parsed dict or an empty one if all attempts fail
+        # 处理 bool
         elif target_type == bool:
             return db_value.lower() in ('true', '1', 'yes', 'on')
+        # 处理 int
         elif target_type == int:
             return int(db_value)
+        # 处理 float
         elif target_type == float:
             return float(db_value)
-        else: # 默认为 str 或其他 pydantic 能处理的类型
+        # 默认为 str 或其他 pydantic 能直接处理的类型
+        else:
             return db_value
     except (ValueError, TypeError, json.JSONDecodeError) as e:
         logger.warning(f"Failed to parse db_value '{db_value}' for key '{key}' as type {target_type}: {e}. Using original string value.")
@@ -161,20 +192,18 @@ async def sync_initial_settings():
                         # 比较解析后的值和内存中的值
                         # 注意：对于列表等复杂类型，直接比较可能不够健壮，但这里简化处理
                         if parsed_db_value != memory_value:
-                             # 检查类型是否匹配，以防解析函数返回了不兼容的类型
-                            # 优先处理 List[str] 类型，避免直接对泛型使用 isinstance
-                            if target_type == List[str]:
-                                if isinstance(parsed_db_value, list):
-                                    # 可以选择性地添加对列表元素的检查，但这里保持简化
-                                    setattr(settings, key, parsed_db_value)
-                                    logger.info(f"Updated setting '{key}' in memory from database value (List[str]).")
-                                    updated_in_memory = True
-                                else:
-                                     logger.warning(f"Parsed DB value type mismatch for key '{key}'. Expected List[str], got {type(parsed_db_value)}. Skipping update.")
-                            # 对于其他非泛型类型，使用常规的 isinstance 检查
-                            elif isinstance(parsed_db_value, target_type):
+                            # 检查类型是否匹配，以防解析函数返回了不兼容的类型
+                            type_match = False
+                            if target_type == List[str] and isinstance(parsed_db_value, list):
+                                type_match = True
+                            elif target_type == Dict[str, float] and isinstance(parsed_db_value, dict):
+                                type_match = True
+                            elif target_type not in (List[str], Dict[str, float]) and isinstance(parsed_db_value, target_type):
+                                type_match = True
+
+                            if type_match:
                                 setattr(settings, key, parsed_db_value)
-                                logger.info(f"Updated setting '{key}' in memory from database value.")
+                                logger.info(f"Updated setting '{key}' in memory from database value ({target_type}).")
                                 updated_in_memory = True
                             else:
                                 logger.warning(f"Parsed DB value type mismatch for key '{key}'. Expected {target_type}, got {type(parsed_db_value)}. Skipping update.")
@@ -205,10 +234,12 @@ async def sync_initial_settings():
 
         for key, value in final_memory_settings.items():
             # 序列化值为字符串或 JSON 字符串
-            if isinstance(value, list):
-                db_value = json.dumps(value)
+            if isinstance(value, (list, dict)): # 处理列表和字典
+                db_value = json.dumps(value, ensure_ascii=False) # 使用 ensure_ascii=False 以支持非 ASCII 字符
             elif isinstance(value, bool):
                 db_value = str(value).lower()
+            elif value is None: # 处理 None 值
+                db_value = "" # 或者根据需要设为 NULL 或其他标记
             else:
                 db_value = str(value)