@agentunion/kite 1.4.0 → 1.5.0

package/extensions/services/proxy/evol/presenter/configPresenter.py

@@ -0,0 +1,1281 @@
+import json
+import os
+import threading
+import time
+
+from ..log import logger
+
+class configPresenter:
+    _lock = threading.Lock()
+    _config_dir_initialized = False 
+    searchPreviewEnabled = False
+    userName = "default"
+    KEY_CLAUDE_AGENT_NAME = "claude_agent_name" # Claude代理Agent名称
+    KEY_GEMINI_AGENT_NAME = "gemini_agent_name" # Gemini代理Agent名称
+    
+    @staticmethod
+    def get_config_dir():
+        """获取配置文件目录，确保PyInstaller打包后也能正常工作"""
+        import platform
+
+        if platform.system() == "Windows":
+            app_path = os.path.join(os.getenv("APPDATA", "~"), "evol",configPresenter.userName)
+        else:
+            home_dir = os.path.expanduser("~")
+            if os.access(home_dir, os.W_OK):
+                app_path = os.path.join(home_dir, ".evol",configPresenter.userName)
+
+            else:
+                import tempfile
+                app_path = os.path.join(tempfile.gettempdir(), "evol",configPresenter.userName)
+        logger.debug(f"using config dir: {app_path}")
+        return app_path
+
+    @staticmethod
+    def ensure_config_dir():
+        """确保配置目录存在，只在需要时创建一次"""
+        if not configPresenter._config_dir_initialized:
+            config_dir = configPresenter.get_config_dir()
+            try:
+                os.makedirs(config_dir, exist_ok=True)
+                configPresenter._config_dir_initialized = True
+            except Exception as e:
+                print(f"创建配置目录失败: {e}")
+                # 降级到临时目录
+                import tempfile
+
+                config_dir = tempfile.gettempdir()
+        return True
+    
+    @staticmethod
+    def get_claude_agent_name():
+        """获取Claude智能体名称"""
+        """获取Claude代理Agent名称，如果未设置则返回默认值"""
+        #return "claude_code_proxy.aid.pub"
+        agent_name = configPresenter.getSetting(configPresenter.KEY_CLAUDE_AGENT_NAME)
+        if agent_name is None:
+            return "claude_code_proxy_1.aid.pub"  # 默认值
+            #return "claude_code_proxy.aid.pub"
+        return agent_name
+
+    @staticmethod
+    def get_gemini_agent_name():
+        """获取Gemini智能体名称"""
+        """获取Gemini代理Agent名称，如果未设置则返回默认值"""
+        agent_name = configPresenter.getSetting(configPresenter.KEY_GEMINI_AGENT_NAME)
+        if agent_name is None:
+            return "gemini_proxy.aid.pub"  # 默认值
+        return agent_name
+
+
+    @staticmethod
+    def get_config_file_path(workspaceName = ""):
+        """获取配置文件的完整路径"""
+        if not workspaceName:
+            configPresenter.ensure_config_dir()  # 确保目录存在
+            config_dir = configPresenter.get_config_dir()
+            return os.path.join(config_dir, "key_value_store.json")
+        else:
+            from evol.presenter.workPresenter import workPresenter
+            workspace = workPresenter.get_evol_workspace_path(workspaceName)
+            return os.path.join(workspace, "key_value_store.json")
+
+    @staticmethod
+    def getSetting(key,workspaceName = ""):
+        """
+        从本地文件读取指定键的值
+        """
+        filepath = configPresenter.get_config_file_path(workspaceName)
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                content = f.read().strip()
+                if not content:  # 如果文件为空
+                    return None
+                data = json.loads(content)
+                value = data.get(key)
+                return value
+        except FileNotFoundError:
+            return None
+        except json.JSONDecodeError as e:
+            logger.error(f"JSON格式错误: {e}")
+            # 如果JSON格式错误，重新创建一个空的配置文件
+            try:
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump({}, f, indent=4, ensure_ascii=False)
+                logger.info("已重新创建配置文件")
+            except Exception as write_error:
+                logger.error(f"重新创建配置文件失败: {write_error}")
+            return None
+        except Exception as e:
+            logger.exception(f"读取设置时出错: {e}")
+            return None
+
+    @staticmethod
+    def setSetting(key, value,workspaceName = ""):
+        """
+        将键值对存储到本地文件（线程安全版本）
+        """
+        logger.info(f"开始保存设置: {key} = {value}")
+        try:
+            with configPresenter._lock:  # 使用线程锁保护临界区
+                filepath = configPresenter.get_config_file_path(workspaceName)
+                if not os.path.exists(filepath):
+                    with open(filepath, "w", encoding="utf-8") as f:
+                        json.dump({}, f, indent=4, ensure_ascii=False)
+
+                # 读取现有数据
+                try:
+                    with open(filepath, "r", encoding="utf-8") as f:
+                        data = json.load(f)
+                except (json.JSONDecodeError, FileNotFoundError):
+                    data = {}
+
+                # 更新数据
+                old_value = data.get(key, "未设置")
+                data[key] = value
+
+                # 写回文件
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump(data, f, indent=4, ensure_ascii=False)
+        except Exception as e:
+            logger.exception(f"保存设置时出错: {e}")
+            return False
+        return True
+    
+    @staticmethod
+    def setCurrentModelInfo(workspaceName,modelId,providerId):
+        configPresenter.setSetting("currentModel", modelId,workspaceName)
+        configPresenter.setSetting("currentProvider", providerId,workspaceName)
+    
+    @staticmethod
+    def getCurrentModelInfo(workspaceName):
+        currentModel = configPresenter.getSetting("currentModel",workspaceName)
+        currentProvider = configPresenter.getSetting("currentProvider",workspaceName)
+        return {"modelId": currentModel, "providerId": currentProvider}
+
+    @staticmethod
+    def setProviderById(key,value):
+        pass
+    
+    @staticmethod
+    def deleteProviders(id):
+        pass
+
+    @staticmethod
+    def addProviders(value):
+        pass
+        
+    @staticmethod
+    def get_fsss2_file_path():
+        """获取fsss2文件的完整路径（用于存储token）"""
+        configPresenter.ensure_config_dir()
+        config_dir = configPresenter.get_config_dir()
+        return os.path.join(config_dir, "fsss2")
+
+    @staticmethod
+    def get_token():
+        """
+        获取token（优先从fsss2文件读取）
+        读取逻辑：
+        1. 先读取fsss2文件
+        2. 如果没读取到，再读取原来位置的token
+        3. 如果原位置有token，写入fsss2文件再返回
+        """
+        fsss2_path = configPresenter.get_fsss2_file_path()
+
+        # 1. 先尝试从fsss2文件读取
+        try:
+            with open(fsss2_path, "r", encoding="utf-8") as f:
+                token = f.read().strip()
+                if token:
+                    return token
+        except FileNotFoundError:
+            pass
+        except Exception as e:
+            logger.error(f"读取fsss2文件时出错: {e}")
+
+        # 2. fsss2没读到，尝试从原位置读取
+        old_token = configPresenter.getSetting("token")
+        if old_token:
+            # 3. 原位置有token，写入fsss2文件
+            try:
+                with open(fsss2_path, "w", encoding="utf-8") as f:
+                    f.write(old_token)
+                logger.info("已将token从原位置迁移到fsss2文件")
+            except Exception as e:
+                logger.error(f"迁移token到fsss2文件时出错: {e}")
+            return old_token
+
+        return None
+
+    @staticmethod
+    def set_token(token: str):
+        """
+        设置token（写入fsss2文件）
+        如果token为空或None，删除fsss2文件以清除token
+        """
+        fsss2_path = configPresenter.get_fsss2_file_path()
+
+        # 如果token为空，删除文件以清除token
+        if not token:
+            try:
+                if os.path.exists(fsss2_path):
+                    os.remove(fsss2_path)
+                    logger.info("token已清除（fsss2文件已删除）")
+                return True
+            except Exception as e:
+                logger.exception(f"清除token时出错: {e}")
+                return False
+
+        try:
+            with open(fsss2_path, "w", encoding="utf-8") as f:
+                f.write(token)
+            logger.info("token已保存到fsss2文件")
+            return True
+        except Exception as e:
+            logger.exception(f"保存token到fsss2文件时出错: {e}")
+            return False
+
+    @staticmethod
+    def set_account_info(username: str, password: str):
+        account_info = {"username": username, "password": password}
+        return configPresenter.setSetting("account_info", json.dumps(account_info))
+
+    @staticmethod
+    def get_account_info():
+        try:
+            user_info = configPresenter.getSetting("account_info")
+            if user_info is None:
+                return None
+            return json.loads(user_info)
+        except:
+            return None
+
+    @staticmethod
+    def set_user_info(aid: str, password: str):
+        user_info = {"aid": aid, "password": password}
+        return configPresenter.setSetting("user_info", json.dumps(user_info))
+
+    @staticmethod
+    def get_user_info():
+        try:
+            user_info = configPresenter.getSetting("user_info")
+            if user_info is None:
+                return None
+            return json.loads(user_info)
+        except:
+            return None
+
+    @staticmethod
+    def getSearchPreviewEnabled():
+        return configPresenter.searchPreviewEnabled
+    
+    @staticmethod
+    def getCustomSearchEngines():
+        return 'baidu'
+    
+    @staticmethod   
+    def getProviders():
+        return []
+        
+    @staticmethod        
+    def getDefaultProviders():
+        return ""
+        
+    @staticmethod    
+    def getLanguage():
+        return "zh-CN"
+    
+    @staticmethod
+    def getModelDefaultConfig(modal):
+        return "";
+    
+    @staticmethod
+    def getArtifactsEffectEnabled():
+        return False
+    
+    @staticmethod
+    def setProviderById(key,value):
+        pass
+    
+    @staticmethod
+    def deleteProviders(id):
+        pass
+
+    @staticmethod
+    def addProviders(value):
+        pass
+        
+    @staticmethod
+    def is_autostart_enabled():
+        return False
+
+    @staticmethod
+    def disable_autostart():
+        return False
+
+    @staticmethod
+    def enable_autostart():
+        return False
+
+    @staticmethod
+    def get_statistics_cache(workspace_name: str):
+        """
+        获取工作空间统计数据缓存
+
+        Args:
+            workspace_name (str): 工作空间名称
+
+        Returns:
+            dict: 缓存数据，包含timestamp和data字段，如果没有缓存则返回None
+        """
+        cache_key = f"statistics_cache_{workspace_name}"
+        return configPresenter.getSetting(cache_key, workspace_name)
+
+    @staticmethod
+    def set_statistics_cache(workspace_name: str, statistics_data: dict):
+        """
+        设置工作空间统计数据缓存
+
+        Args:
+            workspace_name (str): 工作空间名称
+            statistics_data (dict): 统计数据
+
+        Returns:
+            bool: 是否设置成功
+        """
+        cache_key = f"statistics_cache_{workspace_name}"
+        cache_data = {
+            "timestamp": time.time(),
+            "data": statistics_data
+        }
+        return configPresenter.setSetting(cache_key, cache_data, workspace_name)
+
+    @staticmethod
+    def is_statistics_cache_valid(workspace_name: str, cache_timeout: int = 300):
+        """
+        检查统计数据缓存是否有效（默认5分钟过期）
+
+        Args:
+            workspace_name (str): 工作空间名称
+            cache_timeout (int): 缓存超时时间（秒），默认300秒（5分钟）
+
+        Returns:
+            bool: 缓存是否有效
+        """
+        cache_data = configPresenter.get_statistics_cache(workspace_name)
+        if not cache_data or not isinstance(cache_data, dict):
+            return False
+
+        timestamp = cache_data.get("timestamp")
+        if not timestamp:
+            return False
+
+        current_time = time.time()
+        return (current_time - timestamp) < cache_timeout
+
+    @staticmethod
+    def get_default_download_path():
+        """
+        获取系统默认下载路径
+
+        Returns:
+            str: 默认下载路径
+        """
+        import platform
+
+        if platform.system() == "Windows":
+            # Windows系统下载路径
+            downloads_path = os.path.join(os.path.expanduser("~"), "Downloads")
+        elif platform.system() == "Darwin":  # macOS
+            downloads_path = os.path.join(os.path.expanduser("~"), "Downloads")
+        else:  # Linux
+            downloads_path = os.path.join(os.path.expanduser("~"), "Downloads")
+
+        # 确保路径存在
+        if not os.path.exists(downloads_path):
+            try:
+                os.makedirs(downloads_path, exist_ok=True)
+            except Exception as e:
+                logger.error(f"创建下载目录失败: {e}")
+                # 降级到用户主目录
+                downloads_path = os.path.expanduser("~")
+
+        return downloads_path
+
+    @staticmethod
+    def get_download_path():
+        """
+        获取下载路径设置，如果没有设置则返回系统默认下载路径
+
+        Returns:
+            str: 下载路径
+        """
+        download_path = configPresenter.getSetting("download_path")
+        if not download_path:
+            # 如果没有设置，获取系统默认下载路径并保存
+            default_path = configPresenter.get_default_download_path()
+            configPresenter.set_download_path(default_path)
+            return default_path
+        return download_path
+
+    @staticmethod
+    def set_download_path(path: str):
+        """
+        设置下载路径
+
+        Args:
+            path (str): 下载路径
+
+        Returns:
+            bool: 是否设置成功
+        """
+        return configPresenter.setSetting("download_path", path)
+
+    # ============ 默认工作空间路径配置 ============
+
+    @staticmethod
+    def get_default_workspace_path():
+        """
+        获取默认工作空间路径
+
+        Returns:
+            str: 默认工作空间路径，如果未设置则返回None
+        """
+        return configPresenter.getSetting("default_workspace_path")
+
+    @staticmethod
+    def get_default_workspace_base_path():
+        """
+        获取默认工作空间基础路径（系统默认路径）
+
+        Returns:
+            str: 默认工作空间基础路径
+        """
+        return os.path.join(configPresenter.get_config_dir(), "workspace")
+
+    @staticmethod
+    def set_default_workspace_path(path: str):
+        """
+        设置默认工作空间路径
+
+        Args:
+            path (str): 默认工作空间路径
+
+        Returns:
+            bool: 是否设置成功
+        """
+        return configPresenter.setSetting("default_workspace_path", path)
+
+    # ============ AI 网关配置管理 ============
+
+    KEY_AI_GATEWAY_TYPE = "ai_gateway_type"
+    KEY_AI_GATEWAY_CONFIGS = "ai_gateway_configs"
+
+    # 默认网关配置
+    DEFAULT_GATEWAY_CONFIGS = {
+        "local": {
+            "type": "local",
+            "name": "本地网关",
+            "description": "使用本地 ModelGate 服务",
+            "baseUrl": "http://127.0.0.1:13148",
+            "apiVersion": "/v1",
+            "timeout": 30000,
+            "retryCount": 3,
+            "enabled": True
+        },
+        "cloud": {
+            "type": "cloud",
+            "name": "Evol 网关",
+            "description": "使用 Evol 云端服务",
+            # 兜底配置，实际云端地址会由 userPresenter 的网关信息覆盖
+            "baseUrl": "https://mg-new.evolai.cn",
+            "apiVersion": "/v1",
+            "timeout": 30000,
+            "retryCount": 3,
+            "enabled": True
+        }
+    }
+
+    @staticmethod
+    def get_gateway_type():
+        """
+        获取当前网关类型
+
+        Returns:
+            str: 'local' 或 'cloud'，默认 'cloud'
+        """
+        gateway_type = configPresenter.getSetting(configPresenter.KEY_AI_GATEWAY_TYPE)
+        if not gateway_type:
+            # 默认使用云端网关
+            configPresenter.set_gateway_type("cloud")
+            return "cloud"
+        return gateway_type
+
+    @staticmethod
+    def set_gateway_type(gateway_type: str):
+        """
+        设置当前网关类型
+
+        Args:
+            gateway_type (str): 'local', 'cloud', 或 'custom-{id}'
+
+        Returns:
+            bool: 是否设置成功
+        """
+        # 验证网关类型
+        if gateway_type in ["local", "cloud"]:
+            # 预设网关，直接设置
+            logger.info(f"Setting gateway type to: {gateway_type}")
+            return configPresenter.setSetting(configPresenter.KEY_AI_GATEWAY_TYPE, gateway_type)
+        elif gateway_type.startswith("custom-"):
+            # 自定义网关，验证是否存在
+            gateway_id = gateway_type.replace("custom-", "")
+            custom_gateway = configPresenter.get_custom_gateway(gateway_id)
+            if custom_gateway:
+                logger.info(f"Setting gateway type to custom: {gateway_id}")
+                return configPresenter.setSetting(configPresenter.KEY_AI_GATEWAY_TYPE, gateway_type)
+            else:
+                logger.error(f"Custom gateway not found: {gateway_id}")
+                return False
+        else:
+            logger.error(f"Invalid gateway type: {gateway_type}")
+            return False
+
+    @staticmethod
+    def get_gateway_configs():
+        """
+        获取所有网关配置
+
+        Returns:
+            dict: 所有网关配置
+        """
+        #configs = configPresenter.getSetting(configPresenter.KEY_AI_GATEWAY_CONFIGS)
+        #if not configs:
+            # 首次使用，保存默认配置
+        configPresenter.set_gateway_configs(configPresenter.DEFAULT_GATEWAY_CONFIGS)
+        return configPresenter.DEFAULT_GATEWAY_CONFIGS
+        #return configs
+
+    @staticmethod
+    def _apply_cloud_gateway_info(config: dict) -> dict:
+        if not isinstance(config, dict):
+            return config
+
+        try:
+            from .userPresenter import userPresenter
+
+            result = userPresenter.get_cloud_gateway_info()
+            gateway_info = None
+            if isinstance(result, dict):
+                gateway_info = result.get("gateway_info")
+
+            if isinstance(gateway_info, dict):
+                base_url = gateway_info.get("modelBaseUrl") or gateway_info.get("apiUrl")
+                if base_url:
+                    updated = dict(config)
+                    updated["baseUrl"] = base_url
+                    return updated
+        except Exception:
+            return config
+
+        return config
+
+    @staticmethod
+    def set_gateway_configs(configs: dict):
+        """
+        设置所有网关配置
+
+        Args:
+            configs (dict): 网关配置字典
+
+        Returns:
+            bool: 是否设置成功
+        """
+        return configPresenter.setSetting(configPresenter.KEY_AI_GATEWAY_CONFIGS, configs)
+
+    @staticmethod
+    def get_gateway_config(gateway_type: str = None):
+        """
+        获取指定网关的配置（支持自定义网关）
+
+        Args:
+            gateway_type (str): 网关类型，不传则使用当前网关
+
+        Returns:
+            dict: 网关配置
+        """
+        if not gateway_type:
+            gateway_type = configPresenter.get_gateway_type()
+
+        # 检查是否为自定义网关
+        if gateway_type and gateway_type.startswith("custom-"):
+            gateway_id = gateway_type.replace("custom-", "")
+            custom_config = configPresenter.get_custom_gateway(gateway_id)
+            if custom_config:
+                logger.debug(f"Using custom gateway config: {gateway_id}")
+                return custom_config
+            else:
+                logger.warning(f"Custom gateway not found: {gateway_id}, using default cloud gateway")
+                return configPresenter.DEFAULT_GATEWAY_CONFIGS.get("cloud", {})
+
+        # 原有逻辑：本地或云端网关
+        configs = configPresenter.get_gateway_configs()
+        config = configs.get(gateway_type)
+
+        if not config:
+            logger.warning(f"Gateway config not found: {gateway_type}, using default")
+            return configPresenter.DEFAULT_GATEWAY_CONFIGS.get(gateway_type, {})
+
+        if gateway_type == "cloud":
+            return configPresenter._apply_cloud_gateway_info(config)
+
+        return config
+
+    @staticmethod
+    def get_current_gateway_base_url():
+        """
+        获取当前网关的 Base URL
+
+        Returns:
+            str: 当前网关的基础 URL
+        """
+        config = configPresenter.get_gateway_config()
+        return config.get("baseUrl", "http://127.0.0.1:13148")
+
+    @staticmethod
+    def get_current_gateway_api_url():
+        """
+        获取当前网关的 API URL（含版本）
+
+        Returns:
+            str: 当前网关的 API URL
+        """
+        config = configPresenter.get_gateway_config()
+        base_url = config.get("baseUrl", "http://127.0.0.1:13148")
+        api_version = config.get("apiVersion", "/v1")
+        return f"{base_url}{api_version}"
+
+    @staticmethod
+    def get_current_gateway_api_key():
+        """
+        获取当前网关的 API Key
+
+        Returns:
+            str: 当前网关的 API Key，如果没有则返回空字符串
+        """
+        config = configPresenter.get_gateway_config()
+        return config.get("apiKey", "")
+
+    @staticmethod
+    def build_gateway_url(endpoint: str, include_version: bool = True, gateway_type: str = None):
+        """
+        构建完整的网关端点 URL
+
+        Args:
+            endpoint (str): 端点路径
+            include_version (bool): 是否包含版本号
+            gateway_type (str): 网关类型，不传则使用当前网关
+
+        Returns:
+            str: 完整的 URL
+        """
+        config = configPresenter.get_gateway_config(gateway_type)
+        base_url = config.get("baseUrl", "http://127.0.0.1:13148")
+
+        if include_version:
+            api_version = config.get("apiVersion", "/v1")
+            base = f"{base_url}{api_version}"
+        else:
+            base = base_url
+
+        # 确保 endpoint 以 / 开头
+        if not endpoint.startswith("/"):
+            endpoint = f"/{endpoint}"
+
+        return f"{base}{endpoint}"
+
+    # ============ 自定义网关管理 ============
+
+    KEY_CUSTOM_GATEWAYS = "custom_gateways"
+
+    @staticmethod
+    def get_custom_gateways():
+        """
+        获取所有自定义网关配置
+
+        Returns:
+            dict: 自定义网关配置字典，格式为 {gateway_id: config}
+        """
+        gateways = configPresenter.getSetting(configPresenter.KEY_CUSTOM_GATEWAYS)
+        return gateways if gateways else {}
+
+    @staticmethod
+    def add_custom_gateway(config=None):
+        """
+        添加自定义网关
+
+        Args:
+            config (dict): 网关配置，包含 name, baseUrl, apiKey, apiType 等字段
+
+        Returns:
+            dict: {"success": bool, "id": str} 添加结果
+        """
+        import uuid
+
+        try:
+            logger.info(f"add_custom_gateway called with config: {config}")
+            logger.info(f"config type: {type(config)}")
+
+            if config is None:
+                logger.error("Config is None!")
+                return {"success": False, "id": "", "error": "Config is None"}
+
+            if not isinstance(config, dict):
+                logger.error(f"Config is not a dict, it's {type(config)}")
+                return {"success": False, "id": "", "error": f"Config must be dict, got {type(config)}"}
+
+            # 生成唯一ID
+            gateway_id = str(uuid.uuid4())[:8]
+
+            gateways = configPresenter.get_custom_gateways()
+
+            # 根据API类型确定API版本
+            api_type = config.get("apiType", "openai")
+            api_version = "/v1"  # OpenAI风格默认使用 /v1
+
+            # 构建完整的网关配置
+            gateways[gateway_id] = {
+                "id": gateway_id,
+                "type": f"custom-{gateway_id}",
+                "name": config.get("name", "自定义网关"),
+                "description": config.get("description", f"自定义网关 - {config.get('baseUrl', '')}"),
+                "baseUrl": config.get("baseUrl", ""),
+                "apiKey": config.get("apiKey", ""),
+                "apiType": api_type,
+                "apiVersion": api_version,  # 根据API类型自动设置
+                "timeout": config.get("timeout", 30000),
+                "retryCount": config.get("retryCount", 3),
+                "enabled": True,
+                "isCustom": True,
+                "createdAt": time.strftime("%Y-%m-%dT%H:%M:%SZ")
+            }
+
+            success = configPresenter.setSetting(configPresenter.KEY_CUSTOM_GATEWAYS, gateways)
+
+            if success:
+                logger.info(f"Added custom gateway: {gateway_id} - {config.get('name')} (API Type: {api_type})")
+            else:
+                logger.error(f"Failed to add custom gateway: {config.get('name')}")
+
+            return {"success": success, "id": gateway_id}
+        except Exception as e:
+            logger.exception(f"Exception in add_custom_gateway: {e}")
+            return {"success": False, "id": "", "error": str(e)}
+
+    @staticmethod
+    def update_custom_gateway(gateway_id: str, config: dict):
+        """
+        更新自定义网关配置
+
+        Args:
+            gateway_id (str): 网关ID
+            config (dict): 要更新的配置字段
+
+        Returns:
+            bool: 是否更新成功
+        """
+        gateways = configPresenter.get_custom_gateways()
+
+        if gateway_id not in gateways:
+            logger.error(f"Custom gateway not found: {gateway_id}")
+            return False
+
+        # 保留原有的ID、类型和创建时间
+        original = gateways[gateway_id]
+
+        # 如果更新了apiType，需要更新对应的apiVersion
+        if "apiType" in config:
+            api_type = config.get("apiType", "openai")
+            config["apiVersion"] = "/v1"  # OpenAI风格使用 /v1
+
+        # 更新配置（合并新旧配置）
+        updated_config = {
+            **original,
+            **config,
+            "id": gateway_id,  # 确保ID不变
+            "type": f"custom-{gateway_id}",  # 确保type不变
+            "createdAt": original.get("createdAt"),  # 确保创建时间不变
+            "isCustom": True  # 确保isCustom标记不变
+        }
+
+        gateways[gateway_id] = updated_config
+
+        success = configPresenter.setSetting(configPresenter.KEY_CUSTOM_GATEWAYS, gateways)
+
+        if success:
+            logger.info(f"Updated custom gateway: {gateway_id} (API Type: {updated_config.get('apiType', 'openai')})")
+        else:
+            logger.error(f"Failed to update custom gateway: {gateway_id}")
+
+        return success
+
+    @staticmethod
+    def delete_custom_gateway(gateway_id: str):
+        """
+        删除自定义网关
+
+        Args:
+            gateway_id (str): 网关ID
+
+        Returns:
+            bool: 是否删除成功
+        """
+        gateways = configPresenter.get_custom_gateways()
+
+        if gateway_id not in gateways:
+            logger.warning(f"Custom gateway not found for deletion: {gateway_id}")
+            return False
+
+        # 检查是否正在使用该网关
+        current_gateway_type = configPresenter.get_gateway_type()
+        if current_gateway_type == f"custom-{gateway_id}":
+            logger.warning(f"Cannot delete custom gateway {gateway_id}: currently in use")
+            # 自动切换到云端网关
+            configPresenter.set_gateway_type("cloud")
+            logger.info("Switched to cloud gateway")
+
+        del gateways[gateway_id]
+
+        success = configPresenter.setSetting(configPresenter.KEY_CUSTOM_GATEWAYS, gateways)
+
+        if success:
+            logger.info(f"Deleted custom gateway: {gateway_id}")
+        else:
+            logger.error(f"Failed to delete custom gateway: {gateway_id}")
+
+        return success
+
+    @staticmethod
+    def get_custom_gateway(gateway_id: str):
+        """
+        获取指定的自定义网关配置
+
+        Args:
+            gateway_id (str): 网关ID
+
+        Returns:
+            dict: 网关配置，如果不存在则返回None
+        """
+        gateways = configPresenter.get_custom_gateways()
+        return gateways.get(gateway_id)
+
+    # ============ 应用设置配置管理 ============
+
+    KEY_APP_SETTINGS_HTTP_RULE = "app_settings_http_rule"
+
+    @staticmethod
+    def get_app_settings_http_rule():
+        """
+        获取应用设置 - 允许局域网访问配置
+
+        Returns:
+            bool: True 允许局域网访问, False 不允许（默认）
+        """
+        result = configPresenter.getSetting(configPresenter.KEY_APP_SETTINGS_HTTP_RULE)
+        if result is None:
+            return False
+        # 处理字符串类型的返回值
+        if isinstance(result, str):
+            return result.lower() == 'true'
+        return bool(result)
+
+    @staticmethod
+    def set_app_settings_http_rule(enabled: bool):
+        """
+        设置应用设置 - 允许局域网访问配置
+
+        Args:
+            enabled (bool): True 允许局域网访问, False 不允许
+
+        Returns:
+            bool: 是否设置成功
+        """
+        return configPresenter.setSetting(configPresenter.KEY_APP_SETTINGS_HTTP_RULE, enabled)
+
+    # ============ 网络代理配置管理 ============
+
+    # 类变量：内存缓存
+    _proxy_cache = None  # None 表示未加载，True/False 表示配置值
+    KEY_USE_SYSTEM_PROXY = "use_system_proxy"
+
+    @staticmethod
+    def get_use_system_proxy():
+        """
+        获取是否使用系统代理配置（优先从内存缓存读取）
+
+        Returns:
+            bool: True 表示使用系统代理, False 表示不使用（默认）
+        """
+        # 优先从缓存读取
+        if configPresenter._proxy_cache is not None:
+            return configPresenter._proxy_cache
+
+        # 从硬盘加载
+        result = configPresenter.getSetting(configPresenter.KEY_USE_SYSTEM_PROXY)
+        if result is None:
+            value = False  # 默认不使用代理
+        elif isinstance(result, str):
+            value = result.lower() == 'true'
+        else:
+            value = bool(result)
+
+        # 更新缓存
+        configPresenter._proxy_cache = value
+        return value
+
+    @staticmethod
+    def set_use_system_proxy(use_proxy: bool):
+        """
+        设置是否使用系统代理配置（先更新内存，再写硬盘）
+
+        Args:
+            use_proxy (bool): True 表示使用系统代理, False 表示不使用
+
+        Returns:
+            bool: 是否设置成功
+        """
+        # 1. 先更新内存缓存
+        configPresenter._proxy_cache = use_proxy
+
+        # 2. 再写硬盘
+        return configPresenter.setSetting(configPresenter.KEY_USE_SYSTEM_PROXY, use_proxy)
+
+    @staticmethod
+    def load_proxy_config():
+        """
+        启动时加载代理配置到内存（可选调用，懒加载也可以）
+
+        Returns:
+            bool: 当前的代理配置值
+        """
+        return configPresenter.get_use_system_proxy()
+
+    # ============ Tab-MCP 绑定配置管理 ============
+
+    KEY_TAB_MCP_BINDINGS = "tab_mcp_bindings"
+
+    # 默认Tab-MCP绑定配置（硬编码回退值）
+    # V1格式：字符串表示单个MCP名称
+    # 后续V2格式：对象可支持多MCP或SubAgent
+    DEFAULT_TAB_MCP_BINDINGS = {
+        "files": "Evol记忆",
+        "web": "Evol浏览器自动化",
+        "pdf": "PDF助手",
+        "excel": "Evol记忆",
+        "word": "Evol记忆",
+        "terminal": "Evol终端控制器",
+    }
+
+    @staticmethod
+    def get_tab_mcp_bindings():
+        """
+        获取Tab-MCP绑定配置
+
+        Returns:
+            dict: Tab类型到MCP服务名称的映射，格式为 {tabType: mcpServerName}
+        """
+        bindings = configPresenter.getSetting(configPresenter.KEY_TAB_MCP_BINDINGS)
+        if not bindings or not isinstance(bindings, dict):
+            # 返回默认配置
+            return dict(configPresenter.DEFAULT_TAB_MCP_BINDINGS)
+        # 合并默认值，确保新增的tabType有默认配置
+        return {**configPresenter.DEFAULT_TAB_MCP_BINDINGS, **bindings}
+
+    @staticmethod
+    def set_tab_mcp_bindings(bindings: dict):
+        """
+        设置Tab-MCP绑定配置
+
+        Args:
+            bindings (dict): Tab类型到MCP服务名称的映射
+
+        Returns:
+            bool: 是否设置成功
+        """
+        return configPresenter.setSetting(configPresenter.KEY_TAB_MCP_BINDINGS, bindings)
+
+    @staticmethod
+    def get_mcp_for_tab_type(tab_type: str):
+        """
+        获取指定Tab类型的默认MCP服务名称
+
+        Args:
+            tab_type (str): Tab类型
+
+        Returns:
+            str: MCP服务名称，如果未配置返回空字符串
+        """
+        bindings = configPresenter.get_tab_mcp_bindings()
+        return bindings.get(tab_type, "")
+
+    @staticmethod
+    def set_mcp_for_tab_type(tab_type: str, mcp_server_name: str):
+        """
+        设置指定Tab类型的MCP服务
+
+        Args:
+            tab_type (str): Tab类型
+            mcp_server_name (str): MCP服务名称，空字符串表示重置为默认值
+
+        Returns:
+            bool: 是否设置成功
+        """
+        bindings = configPresenter.get_tab_mcp_bindings()
+
+        if mcp_server_name == '':
+            # 空字符串表示重置：删除该key，让默认值生效
+            bindings.pop(tab_type, None)
+        else:
+            # 设置用户自定义的MCP服务
+            bindings[tab_type] = mcp_server_name
+
+        return configPresenter.set_tab_mcp_bindings(bindings)
+
+    # ============ 远程访问控制配置管理 ============
+
+    KEY_REMOTE_ACCESS_ENABLED = "remote_access_enabled"
+    KEY_DISABLED_PAIRING_CODES = "disabled_pairing_codes"
+
+    @staticmethod
+    def get_remote_access_enabled():
+        """
+        获取远程访问总开关状态
+
+        Returns:
+            bool: True 允许远程访问, False 禁止远程访问（默认）
+        """
+        result = configPresenter.getSetting(configPresenter.KEY_REMOTE_ACCESS_ENABLED)
+        if result is None:
+            return False
+        if isinstance(result, str):
+            return result.lower() == 'true'
+        return bool(result)
+
+    @staticmethod
+    def set_remote_access_enabled(enabled: bool):
+        """
+        设置远程访问总开关
+
+        Args:
+            enabled (bool): True 允许远程访问, False 禁止远程访问
+
+        Returns:
+            bool: 是否设置成功
+        """
+        return configPresenter.setSetting(configPresenter.KEY_REMOTE_ACCESS_ENABLED, enabled)
+
+    @staticmethod
+    def get_disabled_pairing_codes():
+        """
+        获取禁用的配对码列表
+
+        Returns:
+            list: 禁用的配对码列表
+        """
+        result = configPresenter.getSetting(configPresenter.KEY_DISABLED_PAIRING_CODES)
+        if result is None:
+            return []
+        if isinstance(result, str):
+            # 支持逗号分隔的字符串格式
+            if not result.strip():
+                return []
+            return [code.strip() for code in result.split(',') if code.strip()]
+        if isinstance(result, list):
+            return result
+        return []
+
+    @staticmethod
+    def set_disabled_pairing_codes(codes: list):
+        """
+        设置禁用的配对码列表
+
+        Args:
+            codes (list): 禁用的配对码列表
+
+        Returns:
+            bool: 是否设置成功
+        """
+        return configPresenter.setSetting(configPresenter.KEY_DISABLED_PAIRING_CODES, codes)
+
+    @staticmethod
+    def add_disabled_pairing_code(code: str):
+        """
+        添加一个禁用的配对码
+
+        Args:
+            code (str): 要禁用的配对码
+
+        Returns:
+            bool: 是否添加成功
+        """
+        if not code or not code.strip():
+            return False
+        codes = configPresenter.get_disabled_pairing_codes()
+        code = code.strip()
+        if code not in codes:
+            codes.append(code)
+            return configPresenter.set_disabled_pairing_codes(codes)
+        return True
+
+    @staticmethod
+    def remove_disabled_pairing_code(code: str):
+        """
+        移除一个禁用的配对码
+
+        Args:
+            code (str): 要移除的配对码
+
+        Returns:
+            bool: 是否移除成功
+        """
+        if not code or not code.strip():
+            return False
+        codes = configPresenter.get_disabled_pairing_codes()
+        code = code.strip()
+        if code in codes:
+            codes.remove(code)
+            return configPresenter.set_disabled_pairing_codes(codes)
+        return True
+
+    @staticmethod
+    def is_pairing_code_disabled(code: str):
+        """
+        检查配对码是否被禁用
+
+        Args:
+            code (str): 配对码
+
+        Returns:
+            bool: True 表示被禁用, False 表示未被禁用
+        """
+        if not code or not code.strip():
+            return False
+        codes = configPresenter.get_disabled_pairing_codes()
+        return code.strip() in codes
+
+    @staticmethod
+    def get_remote_access_config():
+        """
+        获取远程访问配置（总开关 + 禁用的配对码）
+
+        Returns:
+            dict: {
+                "enabled": bool,
+                "disabled_codes": list
+            }
+        """
+        return {
+            "enabled": configPresenter.get_remote_access_enabled(),
+            "disabled_codes": configPresenter.get_disabled_pairing_codes()
+        }
+
+    @staticmethod
+    def set_remote_access_config(enabled: bool = None, disabled_codes: list = None):
+        """
+        设置远程访问配置
+
+        Args:
+            enabled (bool): 总开关状态（可选）
+            disabled_codes (list): 禁用的配对码列表（可选）
+
+        Returns:
+            dict: {"success": bool, "message": str}
+        """
+        try:
+            if enabled is not None:
+                configPresenter.set_remote_access_enabled(enabled)
+            if disabled_codes is not None:
+                configPresenter.set_disabled_pairing_codes(disabled_codes)
+            return {"success": True, "message": "配置已更新"}
+        except Exception as e:
+            return {"success": False, "message": str(e)}
+
+    # ============ 用户默认系统提示词配置管理 ============
+
+    KEY_USER_DEFAULT_SYSTEM_PROMPT = "user_default_system_prompt"
+
+    @staticmethod
+    def get_user_default_system_prompt(workspace_name: str):
+        """
+        获取用户默认系统提示词(workspace级别)
+
+        Args:
+            workspace_name (str): 任务空间名称
+
+        Returns:
+            dict: 提示词数据字典 {'userCustom': str, 'version': str}，如果未设置返回默认值
+        """
+        try:
+            prompt_data = configPresenter.getSetting(
+                configPresenter.KEY_USER_DEFAULT_SYSTEM_PROMPT,
+                workspace_name
+            )
+
+            if not prompt_data:
+                # 返回默认值
+                return {'userCustom': '', 'version': '1.0'}
+
+            # 兼容旧格式(字符串)
+            if isinstance(prompt_data, str):
+                try:
+                    return json.loads(prompt_data)
+                except json.JSONDecodeError:
+                    # 如果不是JSON,当作纯文本处理
+                    return {'userCustom': prompt_data, 'version': '1.0'}
+
+            # 新格式(字典)
+            return prompt_data
+        except Exception as e:
+            logger.exception(f"获取用户默认系统提示词失败: {e}")
+            return {'userCustom': '', 'version': '1.0'}
+
+    @staticmethod
+    def set_user_default_system_prompt(workspace_name: str, prompt_data: dict):
+        """
+        设置用户默认系统提示词(workspace级别)
+
+        Args:
+            workspace_name (str): 任务空间名称
+            prompt_data (dict): 提示词数据 {'userCustom': str, 'version': str}
+
+        Returns:
+            bool: 是否设置成功
+        """
+        try:
+            if not isinstance(prompt_data, dict):
+                logger.error(f"prompt_data必须是字典类型,当前类型: {type(prompt_data)}")
+                return False
+
+            # 确保包含必要字段
+            if 'userCustom' not in prompt_data:
+                prompt_data['userCustom'] = ''
+            if 'version' not in prompt_data:
+                prompt_data['version'] = '1.0'
+
+            success = configPresenter.setSetting(
+                configPresenter.KEY_USER_DEFAULT_SYSTEM_PROMPT,
+                prompt_data,
+                workspace_name
+            )
+
+            if success:
+                logger.info(f"已保存用户默认系统提示词到workspace: {workspace_name}")
+            else:
+                logger.error(f"保存用户默认系统提示词失败: {workspace_name}")
+
+            return success
+        except Exception as e:
+            logger.exception(f"设置用户默认系统提示词失败: {e}")
+            return False
+