feat: 重构LLM配置为Provider模板+Dify应用+Scene绑定

变更项：

1. 新增 LLM 目录数据层（t_llm_provider_templates/t_llm_dify_apps/t_llm_backends/t_llm_scenes/t_llm_catalog_meta），支持三层配置管理。

2. Robot 启动接入 llm_catalog_db：自动建表并从旧 llm(backends/scenes) 配置迁移初始化。

3. LLMRegistry 改为优先读取目录模型并按 scene 解析：dify_app 自动合并 Provider 模板与 app_key 差异，降低重复配置。

4. system 蓝图 /api/system/llm_config 改为目录模型读写，新增完整校验（provider引用、app_key、scene目标合法性）。

5. system_llm 页面重构为四块：Provider 模板、Dify 应用、通用 Backend、Scene 绑定，并展示插件依赖拓扑。

6. 保留 YAML 旧结构兜底展示与运行时回退，保证目录表异常时系统仍可运行。

admin/dashboard/blueprints/system.py

@@ -39,41 +39,143 @@ def _save_system_yaml(config_obj: dict) -> None:
         yaml.safe_dump(config_obj, f, allow_unicode=True, sort_keys=False)
 
 
-def _load_llm_config_runtime() -> dict:
-    """读取运行时 LLM 配置。
+def _legacy_llm_to_catalog(legacy_llm: dict) -> dict:
+    """把旧 llm(backends/scenes) 结构转换为新目录结构（仅用于兜底展示）。
 
-    读取优先级：
-    1. 优先从机器人挂载的 MySQL 配置读取（主数据源）；
-    2. 若数据库对象不可用或读取异常，回退到 config.yaml（兜底）。
+    说明：
+    1. 该转换不写库，只用于当目录表不可用时让后台页面仍可展示；
+    2. 规则与 DB bootstrap 一致：dify backend 拆成 provider+dify_app，其他保留为 backend。
     """
+    llm = legacy_llm or {}
+    old_backends = llm.get("backends", {}) or {}
+    old_scenes = llm.get("scenes", {}) or {}
+    default_backend = str(llm.get("default_backend") or "").strip()
+
+    providers = []
+    dify_apps = []
+    backends = []
+    scenes = []
+
+    dify_template_cfg = None
+    for backend in old_backends.values():
+        if isinstance(backend, dict) and str(backend.get("provider") or "").strip().lower() == "dify":
+            dify_template_cfg = dict(backend)
+            break
+    if dify_template_cfg:
+        providers.append(
+            {
+                "name": "dify_workflow_default",
+                "provider_type": "dify",
+                "enabled": True,
+                "config": {
+                    "provider": "dify",
+                    "api_base_url": dify_template_cfg.get("api_base_url", ""),
+                    "endpoint": dify_template_cfg.get("endpoint", "workflows/run"),
+                    "mode": dify_template_cfg.get("mode", "workflow"),
+                    "response_mode": dify_template_cfg.get("response_mode", "blocking"),
+                    "request_timeout": dify_template_cfg.get("request_timeout", 60),
+                    "max_retries": dify_template_cfg.get("max_retries", 3),
+                    "retry_delay_seconds": dify_template_cfg.get("retry_delay_seconds", 1.0),
+                },
+            }
+        )
+
+    for backend_name, backend_cfg in old_backends.items():
+        if not isinstance(backend_cfg, dict):
+            continue
+        provider = str(backend_cfg.get("provider") or "").strip().lower()
+        if provider == "dify":
+            dify_apps.append(
+                {
+                    "name": str(backend_name),
+                    "provider_template": "dify_workflow_default",
+                    "app_key": str(backend_cfg.get("api_key") or "").strip(),
+                    "workflow_output_key": str(backend_cfg.get("workflow_output_key") or "text").strip(),
+                    "enabled": True,
+                    "config": {
+                        "endpoint": backend_cfg.get("endpoint", ""),
+                        "mode": backend_cfg.get("mode", ""),
+                        "response_mode": backend_cfg.get("response_mode", ""),
+                        "request_timeout": backend_cfg.get("request_timeout", ""),
+                    },
+                }
+            )
+        else:
+            backends.append(
+                {
+                    "name": str(backend_name),
+                    "enabled": True,
+                    "config": dict(backend_cfg),
+                }
+            )
+
+    if isinstance(old_scenes, dict) and old_scenes:
+        for scene_name, backend_name in old_scenes.items():
+            scene_name = str(scene_name or "").strip()
+            backend_name = str(backend_name or "").strip()
+            if not scene_name or not backend_name:
+                continue
+            backend_cfg = old_backends.get(backend_name, {}) or {}
+            provider = str((backend_cfg or {}).get("provider") or "").strip().lower()
+            scenes.append(
+                {
+                    "name": scene_name,
+                    "target_type": "dify_app" if provider == "dify" else "backend",
+                    "target_ref": backend_name,
+                    "enabled": True,
+                }
+            )
+    elif default_backend:
+        default_cfg = old_backends.get(default_backend, {}) or {}
+        provider = str((default_cfg or {}).get("provider") or "").strip().lower()
+        scenes.append(
+            {
+                "name": "main.default",
+                "target_type": "dify_app" if provider == "dify" else "backend",
+                "target_ref": default_backend,
+                "enabled": True,
+            }
+        )
+
+    default_scene = scenes[0]["name"] if scenes else ""
+    return {
+        "default_scene": default_scene,
+        "providers": providers,
+        "dify_apps": dify_apps,
+        "backends": backends,
+        "scenes": scenes,
+    }
+
+
+def _load_llm_catalog_runtime() -> dict:
+    """读取运行时 LLM 目录配置（优先 MySQL 新模型）。"""
     try:
         server = current_app.dashboard_server
-        llm_config_db = getattr(server, "llm_config_db", None)
-        if llm_config_db:
-            row = llm_config_db.get_config() or {}
-            if row:
-                return {
-                    "default_backend": row.get("default_backend", ""),
-                    "backends": row.get("backends", {}) or {},
-                    "scenes": row.get("scenes", {}) or {},
-                }
+        llm_catalog_db = getattr(server, "llm_catalog_db", None)
+        if llm_catalog_db:
+            catalog = llm_catalog_db.get_catalog() or {}
+            if catalog and catalog.get("scenes"):
+                return catalog
     except Exception as e:
-        logger.warning(f"从 MySQL 读取 LLM 配置失败，回退 YAML: {e}")
+        logger.warning(f"从 MySQL 读取 LLM 目录失败，回退 YAML: {e}")
 
+    # 兜底：把 YAML 的 legacy llm 转成目录结构给后台展示。
     config_obj = _load_system_yaml()
     llm_config = config_obj.get("llm", {}) or {}
-    return llm_config if isinstance(llm_config, dict) else {}
+    if not isinstance(llm_config, dict):
+        llm_config = {}
+    return _legacy_llm_to_catalog(llm_config)
 
 
-def _save_llm_config_runtime(llm_config: dict) -> None:
-    """保存运行时 LLM 配置到主数据源（MySQL）。"""
+def _save_llm_catalog_runtime(catalog: dict) -> None:
+    """保存运行时 LLM 目录配置到 MySQL。"""
     server = current_app.dashboard_server
-    llm_config_db = getattr(server, "llm_config_db", None)
-    if not llm_config_db:
-        raise RuntimeError("llm_config_db 未初始化，无法保存 LLM 配置到 MySQL")
-    ok = llm_config_db.save_config(llm_config or {}, source="admin")
+    llm_catalog_db = getattr(server, "llm_catalog_db", None)
+    if not llm_catalog_db:
+        raise RuntimeError("llm_catalog_db 未初始化，无法保存 LLM 目录到 MySQL")
+    ok = llm_catalog_db.save_catalog(catalog or {})
     if not ok:
-        raise RuntimeError("保存 LLM 配置到 MySQL 失败")
+        raise RuntimeError("保存 LLM 目录到 MySQL 失败")
 
 
 def _plugins_root_path() -> str:
@@ -142,34 +244,53 @@ def _scan_plugin_llm_usage() -> list:
 
 def _build_llm_topology() -> dict:
     """构建 LLM 拓扑视图（供后台页面直观展示依赖关系）。"""
-    llm_config = _load_llm_config_runtime()
-    scenes = llm_config.get("scenes", {}) or {}
-    backends = llm_config.get("backends", {}) or {}
-    default_backend = str(llm_config.get("default_backend", "") or "").strip()
+    catalog = _load_llm_catalog_runtime()
+    providers = {str(item.get("name") or "").strip(): item for item in (catalog.get("providers", []) or [])}
+    dify_apps = {str(item.get("name") or "").strip(): item for item in (catalog.get("dify_apps", []) or [])}
+    backends = {str(item.get("name") or "").strip(): item for item in (catalog.get("backends", []) or [])}
+    scenes = {str(item.get("name") or "").strip(): item for item in (catalog.get("scenes", []) or [])}
+    default_scene = str(catalog.get("default_scene") or "").strip()
 
     plugin_usages = _scan_plugin_llm_usage()
     topology_rows = []
     for usage in plugin_usages:
         scene_name = str(usage.get("scene") or "").strip()
-        # 严格模式：插件必须声明 scene，后端统一由 scenes 映射解析。
-        resolved_backend = str(scenes.get(scene_name) or "").strip()
-        if not resolved_backend:
-            resolved_backend = default_backend
+        scene = scenes.get(scene_name, {}) or {}
+        target_type = str(scene.get("target_type") or "").strip().lower()
+        target_ref = str(scene.get("target_ref") or "").strip()
+
+        resolved_provider = ""
+        resolved_target = target_ref
+        valid_target = False
+        if target_type == "dify_app":
+            app = dify_apps.get(target_ref, {}) or {}
+            provider_name = str(app.get("provider_template") or "").strip()
+            provider = providers.get(provider_name, {}) or {}
+            resolved_provider = str(provider.get("provider_type") or "").strip()
+            valid_target = bool(app and provider)
+        elif target_type == "backend":
+            backend = backends.get(target_ref, {}) or {}
+            backend_cfg = (backend.get("config") or {}) if isinstance(backend, dict) else {}
+            resolved_provider = str((backend_cfg or {}).get("provider") or "").strip()
+            valid_target = bool(backend)
 
         topology_rows.append({
             "plugin": usage.get("plugin", ""),
             "section": usage.get("section", ""),
             "scene": scene_name,
-            "resolved_backend": resolved_backend,
-            "provider": str((backends.get(resolved_backend) or {}).get("provider", "") or "").strip(),
+            "target_type": target_type or "-",
+            "target_ref": resolved_target or "-",
+            "provider": resolved_provider or "-",
             "valid_scene": bool(scene_name in scenes),
-            "valid_backend": bool((not resolved_backend) or resolved_backend in backends),
+            "valid_target": valid_target,
         })
 
     return {
-        "default_backend": default_backend,
-        "scenes": scenes if isinstance(scenes, dict) else {},
-        "backends": backends if isinstance(backends, dict) else {},
+        "default_scene": default_scene,
+        "providers": catalog.get("providers", []) or [],
+        "dify_apps": catalog.get("dify_apps", []) or [],
+        "backends": catalog.get("backends", []) or [],
+        "scenes": catalog.get("scenes", []) or [],
         "plugin_usages": plugin_usages,
         "topology_rows": topology_rows,
     }
@@ -326,14 +447,15 @@ def get_system_config_raw():
         config_path = _system_config_path()
         with open(config_path, 'r', encoding='utf-8') as f:
             config_text = f.read()
-        # 这里展示“运行时有效”的 LLM 后端列表（优先 MySQL），避免与 YAML 展示不一致。
-        llm_config = _load_llm_config_runtime()
-        llm_backends = (llm_config or {}).get("backends", {})
+        # 展示运行时目录中的目标对象（backend+dify_app），便于调试 scene 绑定。
+        catalog = _load_llm_catalog_runtime()
+        backend_names = [str(item.get("name") or "").strip() for item in (catalog.get("backends", []) or [])]
+        app_names = [f"dify_app::{str(item.get('name') or '').strip()}" for item in (catalog.get("dify_apps", []) or [])]
         return jsonify({
             "success": True,
             "data": config_text,
             "path": config_path,
-            "llm_backends": list((llm_backends or {}).keys()),
+            "llm_backends": sorted([name for name in backend_names + app_names if name]),
         })
     except Exception as e:
         logger.error(f"读取系统配置失败: {e}")
@@ -368,42 +490,27 @@ def update_system_config():
 @login_required
 def get_system_llm_config():
     try:
-        llm_config = _load_llm_config_runtime()
-        backends = llm_config.get("backends", {}) or {}
-        scenes = llm_config.get("scenes", {}) or {}
-        backend_list = []
-        for name, backend in backends.items():
-            if not isinstance(backend, dict):
-                continue
-            item = dict(backend)
-            item["name"] = name
-            backend_list.append(item)
-        backend_list.sort(key=lambda item: item.get("name", ""))
-
-        scene_list = []
-        if isinstance(scenes, dict):
-            for scene_name, backend_name in scenes.items():
-                scene_name = str(scene_name or "").strip()
-                backend_name = str(backend_name or "").strip()
-                if not scene_name:
-                    continue
-                scene_list.append({
-                    "name": scene_name,
-                    "backend": backend_name,
-                })
-        scene_list.sort(key=lambda item: item.get("name", ""))
-
+        catalog = _load_llm_catalog_runtime()
+        providers = sorted((catalog.get("providers", []) or []), key=lambda item: str(item.get("name") or ""))
+        dify_apps = sorted((catalog.get("dify_apps", []) or []), key=lambda item: str(item.get("name") or ""))
+        backends = sorted((catalog.get("backends", []) or []), key=lambda item: str(item.get("name") or ""))
+        scenes = sorted((catalog.get("scenes", []) or []), key=lambda item: str(item.get("name") or ""))
         topology = _build_llm_topology()
         return jsonify({
             "success": True,
             "data": {
-                "default_backend": llm_config.get("default_backend", ""),
-                "backends": backend_list,
-                "scenes": scene_list,
+                "default_scene": catalog.get("default_scene", ""),
+                "providers": providers,
+                "dify_apps": dify_apps,
+                "backends": backends,
+                "scenes": scenes,
                 "topology_rows": topology.get("topology_rows", []),
                 "plugin_usages": topology.get("plugin_usages", []),
-                # 配置来源改为 MySQL；保留 YAML 路径用于排障与一次性导入核对。
-                "config_path": f"mysql:t_llm_config (fallback yaml: {_system_config_path()})",
+                # 新目录模型主存储在 MySQL。
+                "config_path": (
+                    "mysql:t_llm_provider_templates + t_llm_dify_apps + "
+                    "t_llm_backends + t_llm_scenes (fallback yaml)"
+                ),
             }
         })
     except Exception as e:
@@ -417,58 +524,85 @@ def update_system_llm_config():
     try:
         server = current_app.dashboard_server
         data = request.get_json() or {}
-        default_backend = str(data.get("default_backend") or "").strip()
+        default_scene = str(data.get("default_scene") or "").strip()
+        provider_list = data.get("providers", []) or []
+        dify_app_list = data.get("dify_apps", []) or []
         backend_list = data.get("backends", []) or []
         scene_list = data.get("scenes", []) or []
+
+        if not isinstance(provider_list, list):
+            return jsonify({"success": False, "message": "providers 格式不正确"}), 400
+        if not isinstance(dify_app_list, list):
+            return jsonify({"success": False, "message": "dify_apps 格式不正确"}), 400
         if not isinstance(backend_list, list):
             return jsonify({"success": False, "message": "backends 格式不正确"}), 400
         if not isinstance(scene_list, list):
             return jsonify({"success": False, "message": "scenes 格式不正确"}), 400
 
-        normalized_backends = {}
-        for raw in backend_list:
-            if not isinstance(raw, dict):
-                continue
-            name = str(raw.get("name") or "").strip()
-            if not name:
-                continue
-            item = {}
-            for key, value in raw.items():
-                if key == "name":
-                    continue
-                if value is None:
-                    continue
-                if isinstance(value, str):
-                    value = value.strip()
-                    if value == "":
-                        continue
-                item[key] = value
-            normalized_backends[name] = item
+        # 目录级校验：先收集名字集合，便于 scene target 引用校验。
+        provider_names = {
+            str((item or {}).get("name") or "").strip()
+            for item in provider_list
+            if isinstance(item, dict) and str((item or {}).get("name") or "").strip()
+        }
+        dify_app_names = {
+            str((item or {}).get("name") or "").strip()
+            for item in dify_app_list
+            if isinstance(item, dict) and str((item or {}).get("name") or "").strip()
+        }
+        backend_names = {
+            str((item or {}).get("name") or "").strip()
+            for item in backend_list
+            if isinstance(item, dict) and str((item or {}).get("name") or "").strip()
+        }
 
-        if default_backend and default_backend not in normalized_backends:
-            return jsonify({"success": False, "message": "默认后端不存在"}), 400
-
-        normalized_scenes = {}
-        for raw in scene_list:
-            if not isinstance(raw, dict):
+        for app in dify_app_list:
+            if not isinstance(app, dict):
                 continue
-            scene_name = str(raw.get("name") or "").strip()
-            backend_name = str(raw.get("backend") or "").strip()
+            app_name = str(app.get("name") or "").strip()
+            if not app_name:
+                continue
+            provider_template = str(app.get("provider_template") or "").strip()
+            if not provider_template:
+                return jsonify({"success": False, "message": f"Dify应用 {app_name} 未绑定 Provider 模板"}), 400
+            if provider_template not in provider_names:
+                return jsonify({"success": False, "message": f"Dify应用 {app_name} 绑定的 Provider 不存在"}), 400
+            app_key = str(app.get("app_key") or "").strip()
+            if not app_key:
+                return jsonify({"success": False, "message": f"Dify应用 {app_name} 缺少 app_key"}), 400
+
+        scene_names = set()
+        for scene in scene_list:
+            if not isinstance(scene, dict):
+                continue
+            scene_name = str(scene.get("name") or "").strip()
+            target_type = str(scene.get("target_type") or "").strip().lower()
+            target_ref = str(scene.get("target_ref") or "").strip()
             if not scene_name:
                 continue
-            # 严格模式：每个 scene 必须绑定一个有效 backend，避免“空绑定”导致运行时不确定性。
-            if not backend_name:
-                return jsonify({"success": False, "message": f"场景 {scene_name} 未绑定后端"}), 400
-            if backend_name not in normalized_backends:
-                return jsonify({"success": False, "message": f"场景 {scene_name} 绑定的后端不存在"}), 400
-            normalized_scenes[scene_name] = backend_name
+            if scene_name in scene_names:
+                return jsonify({"success": False, "message": f"场景名重复: {scene_name}"}), 400
+            scene_names.add(scene_name)
+            if target_type not in {"dify_app", "backend"}:
+                return jsonify({"success": False, "message": f"场景 {scene_name} target_type 非法"}), 400
+            if not target_ref:
+                return jsonify({"success": False, "message": f"场景 {scene_name} 未绑定目标"}), 400
+            if target_type == "dify_app" and target_ref not in dify_app_names:
+                return jsonify({"success": False, "message": f"场景 {scene_name} 绑定的 dify_app 不存在"}), 400
+            if target_type == "backend" and target_ref not in backend_names:
+                return jsonify({"success": False, "message": f"场景 {scene_name} 绑定的 backend 不存在"}), 400
 
-        llm_config = {
-            "default_backend": default_backend,
-            "backends": normalized_backends,
-            "scenes": normalized_scenes,
+        if default_scene and default_scene not in scene_names:
+            return jsonify({"success": False, "message": "默认场景不存在"}), 400
+
+        catalog = {
+            "default_scene": default_scene,
+            "providers": provider_list,
+            "dify_apps": dify_app_list,
+            "backends": backend_list,
+            "scenes": scene_list,
         }
-        _save_llm_config_runtime(llm_config)
+        _save_llm_catalog_runtime(catalog)
 
         if getattr(server, "robot", None) and getattr(server.robot, "config", None):
             server.robot.config.reload()

admin/dashboard/server.py

@@ -51,6 +51,7 @@ class DashboardServer:
             self.plugin_schedule_db = robot_instance.plugin_schedule_db
             self.plugin_schedule_manager = robot_instance.plugin_schedule_manager
             self.group_plugin_config_db = robot_instance.group_plugin_config_db
+            self.llm_catalog_db = robot_instance.llm_catalog_db
             self.llm_config_db = robot_instance.llm_config_db
             self.group_plugin_config_service = robot_instance.group_plugin_config_service
             # 获取联系人管理器实例

admin/dashboard/templates/system_llm.html

@@ -1,18 +1,17 @@
 {% extends "base.html" %}
 
-{% block title %}全局配置 - 机器人管理后台{% endblock %}
+{% block title %}LLM目录配置 - 机器人管理后台{% endblock %}
 
 {% block content %}
 <div class="page-shell system-page">
     <div class="page-hero">
         <div class="page-hero-copy">
-            <div class="page-eyebrow">LLM Workspace</div>
-            <h1>全局配置</h1>
-            <p>集中维护全局 LLM 后端，插件只引用后端名，不再分散配置密钥和地址。</p>
+            <div class="page-eyebrow">LLM Catalog</div>
+            <h1>LLM目录配置</h1>
+            <p>按 Provider 模板、Dify 应用、Scene 绑定三层维护，减少重复配置和切换成本。</p>
         </div>
         <div class="page-hero-actions">
             <el-button size="mini" plain @click="loadLlmConfig">刷新</el-button>
-            <el-button size="mini" @click="addBackend">新增后端</el-button>
             <el-button size="mini" type="success" @click="saveLlmConfig">保存配置</el-button>
         </div>
     </div>
@@ -20,173 +19,165 @@
     <el-card class="workspace-card" shadow="hover">
         <div slot="header" class="workspace-header">
             <div>
-                <h3>全局 LLM 配置</h3>
-                <p>用表单统一管理 `config.yaml` 中的 `llm.backends`，系统和插件共享同一份后端配置。</p>
+                <h3>目录元信息</h3>
+                <p>默认场景用于兜底路由，建议始终设置一个稳定可用的场景。</p>
             </div>
             <div class="config-meta" v-if="configPath">
-                <span>配置文件：{% raw %}{{ configPath }}{% endraw %}</span>
-                <span>后端数量：{% raw %}{{ llmForm.backends.length }}{% endraw %}</span>
+                <span>配置源：{% raw %}{{ configPath }}{% endraw %}</span>
             </div>
         </div>
-
         <el-form label-width="110px" class="llm-form">
-            <el-form-item label="默认后端">
-                <el-select v-model="llmForm.default_backend" placeholder="请选择默认后端" filterable clearable style="width: 360px;">
-                    <el-option
-                        v-for="item in backendNameOptions"
-                        :key="item"
-                        :label="item"
-                        :value="item">
-                    </el-option>
+            <el-form-item label="默认场景">
+                <el-select v-model="catalog.default_scene" placeholder="请选择默认场景" filterable clearable style="width: 360px;">
+                    <el-option v-for="item in sceneNameOptions" :key="item" :label="item" :value="item"></el-option>
                 </el-select>
             </el-form-item>
         </el-form>
+    </el-card>
 
-        <el-card class="scene-card" shadow="never">
-            <div slot="header" class="workspace-header">
-                <div>
-                    <h3>场景路由（Scene Binding）</h3>
-                    <p>用业务场景绑定后端。插件优先引用 scene，再由 scene 统一路由到 backend。</p>
-                </div>
-                <el-button size="mini" @click="addScene">新增场景</el-button>
+    <el-card class="workspace-card" shadow="hover">
+        <div slot="header" class="workspace-header">
+            <div>
+                <h3>1. Provider 模板</h3>
+                <p>公共连接参数只配置一次：base_url、endpoint、mode、超时等。</p>
             </div>
-
-            <div class="scene-list" v-if="llmForm.scenes.length">
-                <div class="scene-row" v-for="(scene, index) in llmForm.scenes" :key="scene.uid">
-                    <el-input v-model="scene.name" placeholder="例如：chat.main"></el-input>
-                    <el-select v-model="scene.backend" placeholder="绑定后端" filterable>
-                        <el-option v-for="item in backendNameOptions" :key="item" :label="item" :value="item"></el-option>
+            <el-button size="mini" @click="addProvider">新增模板</el-button>
+        </div>
+        <div class="section-list" v-if="catalog.providers.length">
+            <el-card v-for="(item, index) in catalog.providers" :key="item.uid" class="entry-card" shadow="never">
+                <div slot="header" class="entry-header">
+                    <strong>{% raw %}{{ item.name || `Provider ${index + 1}` }}{% endraw %}</strong>
+                    <el-button type="text" class="danger-text" @click="removeProvider(index)">删除</el-button>
+                </div>
+                <div class="entry-grid">
+                    <el-input v-model="item.name" placeholder="模板名，例如：dify_workflow_default"></el-input>
+                    <el-select v-model="item.provider_type" placeholder="Provider类型">
+                        <el-option label="dify" value="dify"></el-option>
+                        <el-option label="openai_compatible" value="openai_compatible"></el-option>
                     </el-select>
-                    <el-button type="text" class="danger-text" @click="removeScene(index)">删除</el-button>
+                    <el-input v-model="item.config.api_base_url" placeholder="API Base URL"></el-input>
+                    <el-input v-model="item.config.endpoint" placeholder="Endpoint，例如：workflows/run"></el-input>
+                    <el-input v-model="item.config.mode" placeholder="mode，例如：workflow"></el-input>
+                    <el-input v-model="item.config.response_mode" placeholder="response_mode，例如：blocking"></el-input>
+                    <el-input-number v-model="item.config.request_timeout" :min="1" :step="1" placeholder="request_timeout"></el-input-number>
+                    <el-input-number v-model="item.config.max_retries" :min="1" :step="1" placeholder="max_retries"></el-input-number>
                 </div>
-            </div>
-            <el-empty v-else description="暂无场景配置，可先新增 chat.main / summary.daily 等"></el-empty>
-        </el-card>
-
-        <div class="backend-list" v-if="llmForm.backends.length">
-            <el-card
-                v-for="(backend, index) in llmForm.backends"
-                :key="backend.uid"
-                class="backend-card"
-                shadow="never">
-                <div slot="header" class="backend-card-header">
-                    <div>
-                        <strong>{% raw %}{{ backend.name || `后端 ${index + 1}` }}{% endraw %}</strong>
-                    </div>
-                    <el-button type="text" class="danger-text" @click="removeBackend(index)">删除</el-button>
-                </div>
-
-                <el-form label-width="110px" class="backend-form">
-                    <div class="backend-grid">
-                        <el-form-item label="后端名称">
-                            <el-input v-model="backend.name" placeholder="例如：dify_workflow_chat"></el-input>
-                        </el-form-item>
-                        <el-form-item label="Provider">
-                            <el-select v-model="backend.provider" placeholder="请选择">
-                                <el-option label="dify" value="dify"></el-option>
-                                <el-option label="openai_compatible" value="openai_compatible"></el-option>
-                            </el-select>
-                        </el-form-item>
-
-                        <el-form-item label="Mode">
-                            <el-select v-model="backend.mode" placeholder="请选择" clearable>
-                                <el-option label="workflow" value="workflow"></el-option>
-                                <el-option label="chat" value="chat"></el-option>
-                                <el-option label="completion" value="completion"></el-option>
-                            </el-select>
-                        </el-form-item>
-                        <el-form-item label="模型">
-                            <el-input v-model="backend.model" placeholder="例如：gpt-5.4"></el-input>
-                        </el-form-item>
-
-                        <el-form-item label="API Base URL">
-                            <el-input v-model="backend.api_base_url" placeholder="例如：http://127.0.0.1:3000/v1"></el-input>
-                        </el-form-item>
-                        <el-form-item label="API URL">
-                            <el-input v-model="backend.api_url" placeholder="完整地址，和 Base URL 二选一"></el-input>
-                        </el-form-item>
-
-                        <el-form-item label="Endpoint">
-                            <el-input v-model="backend.endpoint" placeholder="例如：chat/completions"></el-input>
-                        </el-form-item>
-                        <el-form-item label="API Key">
-                            <el-input v-model="backend.api_key" placeholder="请输入 API Key" show-password></el-input>
-                        </el-form-item>
-
-                        <el-form-item label="响应模式">
-                            <el-select v-model="backend.response_mode" placeholder="请选择" clearable>
-                                <el-option label="blocking" value="blocking"></el-option>
-                                <el-option label="streaming" value="streaming"></el-option>
-                            </el-select>
-                        </el-form-item>
-                        <el-form-item label="输出字段">
-                            <el-input v-model="backend.workflow_output_key" placeholder="例如：text"></el-input>
-                        </el-form-item>
-
-                        <el-form-item label="超时(秒)">
-                            <el-input-number v-model="backend.timeout_seconds" :min="1" :step="1"></el-input-number>
-                        </el-form-item>
-                        <el-form-item label="请求超时">
-                            <el-input-number v-model="backend.request_timeout" :min="1" :step="1"></el-input-number>
-                        </el-form-item>
-
-                        <el-form-item label="温度">
-                            <el-input-number v-model="backend.temperature" :min="0" :max="2" :step="0.05"></el-input-number>
-                        </el-form-item>
-                        <el-form-item label="Max Tokens">
-                            <el-input-number v-model="backend.max_tokens" :min="1" :step="1"></el-input-number>
-                        </el-form-item>
-
-                        <el-form-item label="最大重试">
-                            <el-input-number v-model="backend.max_retries" :min="1" :step="1"></el-input-number>
-                        </el-form-item>
-                        <el-form-item label="重试间隔">
-                            <el-input-number v-model="backend.retry_delay_seconds" :min="0" :step="0.5"></el-input-number>
-                        </el-form-item>
-                    </div>
-
-                    <div class="backend-switches">
-                        <el-switch v-model="backend.stream" active-text="Stream"></el-switch>
-                    </div>
-                </el-form>
             </el-card>
         </div>
+        <el-empty v-else description="暂无 Provider 模板，先新增一个"></el-empty>
+    </el-card>
 
-        <el-empty v-else description="暂无后端配置，先新增一个"></el-empty>
-
-        <el-card class="topology-card" shadow="never">
-            <div slot="header" class="workspace-header">
-                <div>
-                    <h3>插件依赖拓扑</h3>
-                    <p>展示 插件 -> scene -> backend -> provider 的实际映射，便于定位切换影响范围。</p>
-                </div>
+    <el-card class="workspace-card" shadow="hover">
+        <div slot="header" class="workspace-header">
+            <div>
+                <h3>2. Dify 应用</h3>
+                <p>每个应用只维护 app_key 和少量差异项，不再重复写 URL/endpoint 公共参数。</p>
             </div>
-            <el-table :data="topologyRows" size="mini" style="width: 100%">
-                <el-table-column prop="plugin" label="插件" min-width="120"></el-table-column>
-                <el-table-column prop="section" label="配置段" min-width="120"></el-table-column>
-                <el-table-column prop="scene" label="Scene" min-width="140">
-                    <template slot-scope="scope">
-                        <el-tag v-if="scope.row.scene" size="mini" :type="scope.row.valid_scene ? 'success' : 'danger'">
-                            {% raw %}{{ scope.row.scene }}{% endraw %}
-                        </el-tag>
-                        <span v-else>-</span>
-                    </template>
-                </el-table-column>
-                <el-table-column prop="resolved_backend" label="实际Backend" min-width="160">
-                    <template slot-scope="scope">
-                        <el-tag v-if="scope.row.resolved_backend" size="mini" :type="scope.row.valid_backend ? 'success' : 'danger'">
-                            {% raw %}{{ scope.row.resolved_backend }}{% endraw %}
-                        </el-tag>
-                        <span v-else>-</span>
-                    </template>
-                </el-table-column>
-                <el-table-column prop="provider" label="Provider" min-width="120">
-                    <template slot-scope="scope">
-                        <span>{% raw %}{{ scope.row.provider || '-' }}{% endraw %}</span>
-                    </template>
-                </el-table-column>
-            </el-table>
-        </el-card>
+            <el-button size="mini" @click="addDifyApp">新增应用</el-button>
+        </div>
+        <div class="section-list" v-if="catalog.dify_apps.length">
+            <el-card v-for="(item, index) in catalog.dify_apps" :key="item.uid" class="entry-card" shadow="never">
+                <div slot="header" class="entry-header">
+                    <strong>{% raw %}{{ item.name || `DifyApp ${index + 1}` }}{% endraw %}</strong>
+                    <el-button type="text" class="danger-text" @click="removeDifyApp(index)">删除</el-button>
+                </div>
+                <div class="entry-grid">
+                    <el-input v-model="item.name" placeholder="应用名，例如：chat_main"></el-input>
+                    <el-select v-model="item.provider_template" placeholder="绑定 Provider 模板" filterable>
+                        <el-option v-for="name in providerNameOptions" :key="name" :label="name" :value="name"></el-option>
+                    </el-select>
+                    <el-input v-model="item.app_key" placeholder="Dify app key，例如：app-xxxx"></el-input>
+                    <el-input v-model="item.workflow_output_key" placeholder="workflow_output_key，例如：text"></el-input>
+                    <el-input v-model="item.config.mode" placeholder="覆盖 mode（可选）"></el-input>
+                    <el-input v-model="item.config.endpoint" placeholder="覆盖 endpoint（可选）"></el-input>
+                    <el-input v-model="item.config.response_mode" placeholder="覆盖 response_mode（可选）"></el-input>
+                    <el-input-number v-model="item.config.request_timeout" :min="1" :step="1" placeholder="覆盖 request_timeout（可选）"></el-input-number>
+                </div>
+            </el-card>
+        </div>
+        <el-empty v-else description="暂无 Dify 应用"></el-empty>
+    </el-card>
+
+    <el-card class="workspace-card" shadow="hover">
+        <div slot="header" class="workspace-header">
+            <div>
+                <h3>3. 通用 Backend（可选）</h3>
+                <p>用于 openai_compatible 或其他非 Dify 直连能力。</p>
+            </div>
+            <el-button size="mini" @click="addBackend">新增Backend</el-button>
+        </div>
+        <div class="section-list" v-if="catalog.backends.length">
+            <el-card v-for="(item, index) in catalog.backends" :key="item.uid" class="entry-card" shadow="never">
+                <div slot="header" class="entry-header">
+                    <strong>{% raw %}{{ item.name || `Backend ${index + 1}` }}{% endraw %}</strong>
+                    <el-button type="text" class="danger-text" @click="removeBackend(index)">删除</el-button>
+                </div>
+                <div class="entry-grid">
+                    <el-input v-model="item.name" placeholder="backend名，例如：openai_main"></el-input>
+                    <el-input v-model="item.config.provider" placeholder="provider，例如：openai_compatible"></el-input>
+                    <el-input v-model="item.config.api_base_url" placeholder="api_base_url"></el-input>
+                    <el-input v-model="item.config.endpoint" placeholder="endpoint"></el-input>
+                    <el-input v-model="item.config.api_key" placeholder="api_key"></el-input>
+                    <el-input v-model="item.config.model" placeholder="model"></el-input>
+                    <el-input-number v-model="item.config.temperature" :min="0" :max="2" :step="0.05"></el-input-number>
+                    <el-input-number v-model="item.config.max_tokens" :min="1" :step="1"></el-input-number>
+                </div>
+            </el-card>
+        </div>
+        <el-empty v-else description="暂无通用 Backend"></el-empty>
+    </el-card>
+
+    <el-card class="workspace-card" shadow="hover">
+        <div slot="header" class="workspace-header">
+            <div>
+                <h3>4. Scene 绑定</h3>
+                <p>业务场景绑定 dify_app 或 backend，插件只配置 scene。</p>
+            </div>
+            <el-button size="mini" @click="addScene">新增场景</el-button>
+        </div>
+        <div class="section-list" v-if="catalog.scenes.length">
+            <div class="scene-row" v-for="(item, index) in catalog.scenes" :key="item.uid">
+                <el-input v-model="item.name" placeholder="scene 名，例如：chat.main"></el-input>
+                <el-select v-model="item.target_type" placeholder="目标类型">
+                    <el-option label="dify_app" value="dify_app"></el-option>
+                    <el-option label="backend" value="backend"></el-option>
+                </el-select>
+                <el-select v-model="item.target_ref" placeholder="目标引用" filterable>
+                    <el-option v-for="target in getSceneTargetOptions(item.target_type)" :key="target" :label="target" :value="target"></el-option>
+                </el-select>
+                <el-button type="text" class="danger-text" @click="removeScene(index)">删除</el-button>
+            </div>
+        </div>
+        <el-empty v-else description="暂无 Scene 绑定"></el-empty>
+    </el-card>
+
+    <el-card class="workspace-card" shadow="hover">
+        <div slot="header" class="workspace-header">
+            <div>
+                <h3>插件依赖拓扑</h3>
+                <p>显示 插件 -> scene -> target_type/target_ref -> provider，便于评估切换影响。</p>
+            </div>
+        </div>
+        <el-table :data="topologyRows" size="mini" style="width: 100%">
+            <el-table-column prop="plugin" label="插件" min-width="120"></el-table-column>
+            <el-table-column prop="section" label="配置段" min-width="120"></el-table-column>
+            <el-table-column prop="scene" label="Scene" min-width="140">
+                <template slot-scope="scope">
+                    <el-tag size="mini" :type="scope.row.valid_scene ? 'success' : 'danger'">
+                        {% raw %}{{ scope.row.scene || '-' }}{% endraw %}
+                    </el-tag>
+                </template>
+            </el-table-column>
+            <el-table-column prop="target_type" label="TargetType" min-width="110"></el-table-column>
+            <el-table-column prop="target_ref" label="TargetRef" min-width="160">
+                <template slot-scope="scope">
+                    <el-tag size="mini" :type="scope.row.valid_target ? 'success' : 'danger'">
+                        {% raw %}{{ scope.row.target_ref || '-' }}{% endraw %}
+                    </el-tag>
+                </template>
+            </el-table-column>
+            <el-table-column prop="provider" label="Provider" min-width="120"></el-table-column>
+        </el-table>
     </el-card>
 </div>
 {% endblock %}
@@ -201,18 +192,27 @@
                 currentView: '17',
                 configPath: '',
                 topologyRows: [],
-                llmForm: {
-                    default_backend: '',
+                catalog: {
+                    default_scene: '',
+                    providers: [],
+                    dify_apps: [],
                     backends: [],
                     scenes: []
                 }
             }
         },
         computed: {
+            sceneNameOptions() {
+                return (this.catalog.scenes || []).map(item => item.name).filter(Boolean);
+            },
+            providerNameOptions() {
+                return (this.catalog.providers || []).map(item => item.name).filter(Boolean);
+            },
             backendNameOptions() {
-                return (this.llmForm.backends || [])
-                    .map(item => item.name)
-                    .filter(Boolean);
+                return (this.catalog.backends || []).map(item => item.name).filter(Boolean);
+            },
+            difyAppNameOptions() {
+                return (this.catalog.dify_apps || []).map(item => item.name).filter(Boolean);
             }
         },
         mounted() {
@@ -220,129 +220,230 @@
             this.loadLlmConfig();
         },
         methods: {
-            newBackend() {
-                // 统一后端对象结构，保证新增/编辑时字段完整，避免后端清洗时丢键。
+            newUid() {
+                return `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+            },
+            // Provider 模板：只放公共字段，避免 Dify 每个应用重复填写。
+            newProvider() {
                 return {
-                    uid: `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+                    uid: this.newUid(),
                     name: '',
-                    provider: 'dify',
-                    mode: '',
-                    model: '',
-                    api_base_url: '',
-                    api_url: '',
-                    endpoint: '',
-                    api_key: '',
-                    response_mode: '',
-                    workflow_output_key: '',
-                    timeout_seconds: 60,
-                    request_timeout: 60,
-                    temperature: 0.7,
-                    max_tokens: 1024,
-                    max_retries: 3,
-                    retry_delay_seconds: 1.0,
-                    stream: false
+                    provider_type: 'dify',
+                    enabled: true,
+                    config: {
+                        provider: 'dify',
+                        api_base_url: '',
+                        endpoint: 'workflows/run',
+                        mode: 'workflow',
+                        response_mode: 'blocking',
+                        request_timeout: 60,
+                        max_retries: 3,
+                        retry_delay_seconds: 1.0
+                    }
+                };
+            },
+            // Dify 应用：只保留 app_key 与少量覆盖项，维护成本最低。
+            newDifyApp() {
+                return {
+                    uid: this.newUid(),
+                    name: '',
+                    provider_template: '',
+                    app_key: '',
+                    workflow_output_key: 'text',
+                    enabled: true,
+                    config: {
+                        mode: '',
+                        endpoint: '',
+                        response_mode: '',
+                        request_timeout: 60
+                    }
+                };
+            },
+            newBackend() {
+                return {
+                    uid: this.newUid(),
+                    name: '',
+                    enabled: true,
+                    config: {
+                        provider: 'openai_compatible',
+                        api_base_url: '',
+                        endpoint: 'chat/completions',
+                        api_key: '',
+                        model: '',
+                        temperature: 0.7,
+                        max_tokens: 1024
+                    }
                 };
             },
             newScene() {
-                // Scene 是“业务场景 -> 后端”的路由单元，插件建议只依赖 scene。
                 return {
-                    uid: `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+                    uid: this.newUid(),
                     name: '',
-                    backend: ''
+                    target_type: 'dify_app',
+                    target_ref: '',
+                    enabled: true
+                };
+            },
+            normalizeProvider(item) {
+                return {
+                    uid: this.newUid(),
+                    name: item.name || '',
+                    provider_type: item.provider_type || 'dify',
+                    enabled: item.enabled !== false,
+                    config: { ...(item.config || {}) }
+                };
+            },
+            normalizeDifyApp(item) {
+                return {
+                    uid: this.newUid(),
+                    name: item.name || '',
+                    provider_template: item.provider_template || '',
+                    app_key: item.app_key || '',
+                    workflow_output_key: item.workflow_output_key || 'text',
+                    enabled: item.enabled !== false,
+                    config: { ...(item.config || {}) }
                 };
             },
             normalizeBackend(item) {
                 return {
-                    uid: `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+                    uid: this.newUid(),
                     name: item.name || '',
-                    provider: item.provider || 'dify',
-                    mode: item.mode || '',
-                    model: item.model || '',
-                    api_base_url: item.api_base_url || '',
-                    api_url: item.api_url || '',
-                    endpoint: item.endpoint || '',
-                    api_key: item.api_key || '',
-                    response_mode: item.response_mode || '',
-                    workflow_output_key: item.workflow_output_key || '',
-                    timeout_seconds: item.timeout_seconds ?? 60,
-                    request_timeout: item.request_timeout ?? 60,
-                    temperature: item.temperature ?? 0.7,
-                    max_tokens: item.max_tokens ?? 1024,
-                    max_retries: item.max_retries ?? 3,
-                    retry_delay_seconds: item.retry_delay_seconds ?? 1.0,
-                    stream: !!item.stream
+                    enabled: item.enabled !== false,
+                    config: { ...(item.config || {}) }
                 };
             },
             normalizeScene(item) {
                 return {
-                    uid: `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+                    uid: this.newUid(),
                     name: item.name || '',
-                    backend: item.backend || ''
+                    target_type: item.target_type || 'dify_app',
+                    target_ref: item.target_ref || '',
+                    enabled: item.enabled !== false
                 };
             },
-            addBackend() {
-                this.llmForm.backends.push(this.newBackend());
-            },
-            addScene() {
-                this.llmForm.scenes.push(this.newScene());
-            },
-            removeBackend(index) {
-                const removed = this.llmForm.backends[index];
-                this.llmForm.backends.splice(index, 1);
-                if (removed && removed.name && this.llmForm.default_backend === removed.name) {
-                    this.llmForm.default_backend = '';
-                }
-                // 后端被删除后，自动清理引用它的 scene，避免保存时出现无效绑定。
+            addProvider() { this.catalog.providers.push(this.newProvider()); },
+            removeProvider(index) {
+                const removed = this.catalog.providers[index];
+                this.catalog.providers.splice(index, 1);
                 if (removed && removed.name) {
-                    (this.llmForm.scenes || []).forEach(scene => {
-                        if (scene.backend === removed.name) {
-                            scene.backend = '';
+                    (this.catalog.dify_apps || []).forEach(app => {
+                        if (app.provider_template === removed.name) {
+                            app.provider_template = '';
                         }
                     });
                 }
             },
+            addDifyApp() { this.catalog.dify_apps.push(this.newDifyApp()); },
+            removeDifyApp(index) {
+                const removed = this.catalog.dify_apps[index];
+                this.catalog.dify_apps.splice(index, 1);
+                if (removed && removed.name) {
+                    (this.catalog.scenes || []).forEach(scene => {
+                        if (scene.target_type === 'dify_app' && scene.target_ref === removed.name) {
+                            scene.target_ref = '';
+                        }
+                    });
+                }
+            },
+            addBackend() { this.catalog.backends.push(this.newBackend()); },
+            removeBackend(index) {
+                const removed = this.catalog.backends[index];
+                this.catalog.backends.splice(index, 1);
+                if (removed && removed.name) {
+                    (this.catalog.scenes || []).forEach(scene => {
+                        if (scene.target_type === 'backend' && scene.target_ref === removed.name) {
+                            scene.target_ref = '';
+                        }
+                    });
+                }
+            },
+            addScene() { this.catalog.scenes.push(this.newScene()); },
             removeScene(index) {
-                this.llmForm.scenes.splice(index, 1);
+                const removed = this.catalog.scenes[index];
+                this.catalog.scenes.splice(index, 1);
+                if (removed && removed.name && this.catalog.default_scene === removed.name) {
+                    this.catalog.default_scene = '';
+                }
+            },
+            getSceneTargetOptions(targetType) {
+                if (targetType === 'backend') {
+                    return this.backendNameOptions;
+                }
+                return this.difyAppNameOptions;
             },
             async loadLlmConfig() {
                 try {
                     const response = await axios.get('/api/system/llm_config');
-                    if (response.data.success) {
-                        const data = response.data.data || {};
-                        this.configPath = data.config_path || '';
-                        this.llmForm.default_backend = data.default_backend || '';
-                        this.llmForm.backends = (data.backends || []).map(item => this.normalizeBackend(item));
-                        this.llmForm.scenes = (data.scenes || []).map(item => this.normalizeScene(item));
-                        this.topologyRows = data.topology_rows || [];
-                    } else {
-                        this.$message.error(response.data.message || '读取全局 LLM 配置失败');
+                    if (!response.data.success) {
+                        this.$message.error(response.data.message || '读取 LLM 目录失败');
+                        return;
                     }
+                    const data = response.data.data || {};
+                    this.configPath = data.config_path || '';
+                    this.catalog.default_scene = data.default_scene || '';
+                    this.catalog.providers = (data.providers || []).map(item => this.normalizeProvider(item));
+                    this.catalog.dify_apps = (data.dify_apps || []).map(item => this.normalizeDifyApp(item));
+                    this.catalog.backends = (data.backends || []).map(item => this.normalizeBackend(item));
+                    this.catalog.scenes = (data.scenes || []).map(item => this.normalizeScene(item));
+                    this.topologyRows = data.topology_rows || [];
                 } catch (error) {
-                    this.$message.error(error.response?.data?.message || '读取全局 LLM 配置失败');
+                    this.$message.error(error.response?.data?.message || '读取 LLM 目录失败');
                 }
             },
             async saveLlmConfig() {
-                // 前端先做一次严格校验，避免把空场景名或未绑定后端的记录提交到后端。
-                const invalidScene = (this.llmForm.scenes || []).find(item => {
-                    return !String(item.name || '').trim() || !String(item.backend || '').trim();
-                });
-                if (invalidScene) {
-                    this.$message.error('场景配置不完整：请确保每一行都填写场景名并绑定后端');
+                // 严格校验：防止提交残缺目录导致运行时无法路由。
+                const invalidProvider = (this.catalog.providers || []).find(item => !String(item.name || '').trim());
+                if (invalidProvider) {
+                    this.$message.error('Provider 模板名称不能为空');
                     return;
                 }
+                const invalidApp = (this.catalog.dify_apps || []).find(item => {
+                    return !String(item.name || '').trim()
+                        || !String(item.provider_template || '').trim()
+                        || !String(item.app_key || '').trim();
+                });
+                if (invalidApp) {
+                    this.$message.error('Dify 应用缺少必填项（name/provider_template/app_key）');
+                    return;
+                }
+                const invalidScene = (this.catalog.scenes || []).find(item => {
+                    return !String(item.name || '').trim()
+                        || !String(item.target_type || '').trim()
+                        || !String(item.target_ref || '').trim();
+                });
+                if (invalidScene) {
+                    this.$message.error('Scene 绑定缺少必填项（name/target_type/target_ref）');
+                    return;
+                }
+                if (this.catalog.default_scene && !this.sceneNameOptions.includes(this.catalog.default_scene)) {
+                    this.$message.error('默认场景不存在，请重新选择');
+                    return;
+                }
+
                 const payload = {
-                    default_backend: this.llmForm.default_backend || '',
-                    backends: (this.llmForm.backends || []).map(item => {
+                    default_scene: this.catalog.default_scene || '',
+                    providers: (this.catalog.providers || []).map(item => {
                         const cleaned = { ...item };
                         delete cleaned.uid;
                         return cleaned;
                     }),
-                    scenes: (this.llmForm.scenes || []).map(item => {
+                    dify_apps: (this.catalog.dify_apps || []).map(item => {
+                        const cleaned = { ...item };
+                        delete cleaned.uid;
+                        return cleaned;
+                    }),
+                    backends: (this.catalog.backends || []).map(item => {
+                        const cleaned = { ...item };
+                        delete cleaned.uid;
+                        return cleaned;
+                    }),
+                    scenes: (this.catalog.scenes || []).map(item => {
                         const cleaned = { ...item };
                         delete cleaned.uid;
                         return cleaned;
                     })
                 };
+
                 try {
                     const response = await axios.post('/api/system/llm_config', payload);
                     if (response.data.success) {
@@ -359,45 +460,37 @@
     });
 </script>
 <style>
-    .system-page { display: flex; flex-direction: column; gap: 24px; }
+    .system-page { display: flex; flex-direction: column; gap: 20px; }
     .page-hero {
         display: flex; align-items: flex-end; justify-content: space-between; gap: 24px;
         background: linear-gradient(135deg, rgba(248,250,252,0.96), rgba(226,232,240,0.88));
         border: 1px solid rgba(148,163,184,0.16);
         border-radius: 24px; padding: 28px 32px; box-shadow: 0 18px 48px rgba(15,23,42,0.06);
     }
-    .page-eyebrow { font-size: 12px; text-transform: uppercase; letter-spacing: .08em; color: #6366f1; font-weight: 700; margin-bottom: 8px; }
+    .page-eyebrow { font-size: 12px; text-transform: uppercase; letter-spacing: .08em; color: #0ea5e9; font-weight: 700; margin-bottom: 8px; }
     .page-hero-copy h1 { font-size: 30px; line-height: 1.1; margin-bottom: 10px; color: #0f172a; }
     .page-hero-copy p { color: #64748b; font-size: 14px; }
-    .workspace-card .el-card__body { display: flex; flex-direction: column; gap: 16px; }
+    .workspace-card { border-radius: 18px; border: 1px solid rgba(148,163,184,0.16); }
     .workspace-header { display: flex; align-items: center; justify-content: space-between; gap: 16px; }
     .workspace-header h3 { font-size: 18px; margin-bottom: 4px; }
     .workspace-header p { font-size: 13px; color: #64748b; }
     .config-meta { display: flex; gap: 12px; color: #64748b; font-size: 12px; flex-wrap: wrap; }
-    .backend-list { display: flex; flex-direction: column; gap: 16px; }
-    .scene-card, .topology-card { border-radius: 18px; border: 1px solid rgba(148,163,184,0.16); }
-    .scene-list { display: flex; flex-direction: column; gap: 10px; }
+    .section-list { display: flex; flex-direction: column; gap: 12px; }
+    .entry-card { border: 1px solid rgba(148,163,184,0.16); border-radius: 14px; }
+    .entry-header { display: flex; align-items: center; justify-content: space-between; gap: 12px; }
+    .entry-grid { display: grid; grid-template-columns: repeat(2, minmax(220px, 1fr)); gap: 10px 14px; }
     .scene-row {
         display: grid;
-        grid-template-columns: minmax(260px, 1fr) minmax(260px, 1fr) auto;
+        grid-template-columns: minmax(260px, 1fr) minmax(160px, 220px) minmax(220px, 1fr) auto;
         gap: 10px;
         align-items: center;
     }
-    .backend-card { border-radius: 18px; border: 1px solid rgba(148,163,184,0.16); }
-    .backend-card-header { display: flex; align-items: center; justify-content: space-between; gap: 12px; }
-    .backend-grid {
-        display: grid;
-        grid-template-columns: repeat(2, minmax(260px, 1fr));
-        gap: 8px 16px;
-    }
-    .backend-switches { display: flex; align-items: center; gap: 16px; padding: 0 12px 8px; }
     .danger-text { color: #dc2626; }
     @media (max-width: 960px) {
         .page-hero { flex-direction: column; align-items: flex-start; }
         .workspace-header { flex-direction: column; align-items: flex-start; }
-        .page-hero-actions { flex-wrap: wrap; }
+        .entry-grid { grid-template-columns: 1fr; }
         .scene-row { grid-template-columns: 1fr; }
-        .backend-grid { grid-template-columns: 1fr; }
     }
 </style>
 {% endblock %}