openclaw_quick_config_gui.py

#!/usr/bin/env python3

import argparse
import contextlib
import importlib.util
import io
import json
import os
import pathlib
import shutil
import shlex
import subprocess
import sys
import threading
import time
import traceback
import urllib.error
import urllib.request
from typing import Any, Dict, List, Optional, Tuple

tk: Any
ttk: Any
filedialog: Any
messagebox: Any
scrolledtext: Any
TK_IMPORT_ERROR: Optional[Exception] = None

try:
    import tkinter as tk  # noqa: F401
    from tkinter import filedialog, messagebox, scrolledtext, ttk  # noqa: F401
except Exception as exc:
    TK_IMPORT_ERROR = exc


DEFAULT_CONFIG_PATH = pathlib.Path.home() / ".openclaw" / "openclaw.json"

I18N = {
    "app_title": {
        "zh": "OpenClaw 快速配置管理器",
        "en": "OpenClaw Quick Config Manager",
    },
    "status_ready": {"zh": "就绪", "en": "Ready"},
    "label_config": {"zh": "配置文件", "en": "Config"},
    "btn_browse": {"zh": "浏览", "en": "Browse"},
    "btn_refresh": {"zh": "刷新", "en": "Refresh"},
    "label_primary": {"zh": "默认模型", "en": "Primary"},
    "label_language": {"zh": "语言", "en": "Language"},
    "provider_list": {"zh": "提供商列表", "en": "Providers"},
    "model_list": {"zh": "模型列表（当前提供商）", "en": "Models (selected provider)"},
    "label_provider_id": {"zh": "提供商 ID", "en": "Provider ID"},
    "label_api_mode": {"zh": "API 模式", "en": "API Mode"},
    "label_base_url": {"zh": "基础地址", "en": "Base URL"},
    "label_api_key": {"zh": "API 密钥", "en": "API Key"},
    "label_model_id": {"zh": "模型 ID", "en": "Model ID"},
    "label_model_name": {"zh": "模型名称", "en": "Model Name"},
    "label_inputs": {"zh": "输入类型", "en": "Inputs"},
    "label_context_window": {"zh": "上下文窗口", "en": "Context Window"},
    "label_max_tokens": {"zh": "最大 Tokens", "en": "Max Tokens"},
    "check_reasoning": {"zh": "推理模型", "en": "Reasoning"},
    "check_auth_header": {"zh": "启用 authHeader", "en": "Enable authHeader"},
    "label_headers": {
        "zh": "请求头（每行 KEY=VALUE）",
        "en": "Headers (KEY=VALUE per line)",
    },
    "label_fallbacks": {
        "zh": "备用模型（逗号分隔 provider/model）",
        "en": "Fallbacks (comma-separated provider/model)",
    },
    "check_set_primary": {"zh": "设为默认模型", "en": "Set as primary"},
    "check_restart_gateway": {
        "zh": "写入后重启网关",
        "en": "Restart gateway after write",
    },
    "check_probe_after": {"zh": "写入后探测可用性", "en": "Probe after write"},
    "btn_upsert": {"zh": "保存提供商和模型", "en": "Upsert Provider + Model"},
    "btn_set_primary": {"zh": "将当前选择设为默认", "en": "Set Selected As Primary"},
    "btn_probe": {"zh": "探测模型", "en": "Probe Models"},
    "btn_restart_gateway": {"zh": "重启网关", "en": "Restart Gateway"},
    "btn_wizard": {"zh": "新增模型向导", "en": "New Model Wizard"},
    "label_primary_ref": {"zh": "默认模型引用", "en": "Primary Ref"},
    "label_log": {"zh": "日志", "en": "Log"},
    "dialog_select_config": {"zh": "选择 openclaw.json", "en": "Select openclaw.json"},
    "filetype_json": {"zh": "JSON 文件", "en": "JSON"},
    "filetype_all": {"zh": "所有文件", "en": "All"},
    "status_load_failed": {
        "zh": "读取配置失败: {error}",
        "en": "Read config failed: {error}",
    },
    "log_load_failed": {
        "zh": "读取配置错误: {error}",
        "en": "ERROR reading config: {error}",
    },
    "status_loaded": {"zh": "配置已加载", "en": "Config loaded"},
    "log_loaded": {"zh": "已从配置加载提供商", "en": "Loaded providers from config"},
    "err_header_line": {
        "zh": "无效请求头 '{line}'，应为 KEY=VALUE",
        "en": "Invalid header line '{line}', expected KEY=VALUE",
    },
    "err_header_key": {
        "zh": "无效请求头键名: '{line}'",
        "en": "Invalid header key in line '{line}'",
    },
    "status_cmd_failed": {
        "zh": "命令执行失败 ({code})",
        "en": "Command failed ({code})",
    },
    "status_cmd_ok": {"zh": "命令执行成功", "en": "Command succeeded"},
    "err_provider_required": {
        "zh": "提供商 ID 不能为空",
        "en": "Provider ID is required",
    },
    "err_base_url_required": {"zh": "Base URL 不能为空", "en": "Base URL is required"},
    "err_api_key_required": {"zh": "API Key 不能为空", "en": "API Key is required"},
    "err_model_id_required": {"zh": "模型 ID 不能为空", "en": "Model ID is required"},
    "title_success": {"zh": "成功", "en": "Success"},
    "title_failed": {"zh": "失败", "en": "Failed"},
    "title_error": {"zh": "错误", "en": "Error"},
    "msg_saved": {
        "zh": "提供商和模型已保存。",
        "en": "Provider/model upserted successfully.",
    },
    "msg_cmd_failed": {
        "zh": "命令执行失败，退出码 {code}。",
        "en": "Command failed with exit code {code}.",
    },
    "log_error": {"zh": "错误: {error}", "en": "ERROR: {error}"},
    "msg_primary_required": {
        "zh": "需要填写默认模型引用（provider/model）。",
        "en": "Primary ref is required (provider/model).",
    },
    "msg_primary_set": {
        "zh": "默认模型已设置为 {primary_ref}。",
        "en": "Primary set to {primary_ref}.",
    },
    "title_probe": {"zh": "探测", "en": "Probe"},
    "msg_probe_done": {"zh": "模型探测完成。", "en": "Probe completed successfully."},
    "title_probe_failed": {"zh": "探测失败", "en": "Probe Failed"},
    "msg_probe_failed": {
        "zh": "模型探测失败，退出码 {code}。",
        "en": "Probe failed with exit code {code}.",
    },
    "title_gateway": {"zh": "网关", "en": "Gateway"},
    "msg_gateway_done": {
        "zh": "网关重启命令已执行。",
        "en": "Gateway restart command executed.",
    },
    "title_gateway_failed": {"zh": "网关失败", "en": "Gateway Failed"},
    "msg_gateway_failed": {
        "zh": "重启失败，退出码 {code}。",
        "en": "Restart failed with exit code {code}.",
    },
    "tk_unavailable": {
        "zh": "Tkinter 不可用: {error}",
        "en": "Tkinter is unavailable: {error}",
    },
    "cli_missing": {
        "zh": "未找到所需 CLI 脚本: {path}",
        "en": "Required CLI script not found: {path}",
    },
    "log_gui_started": {"zh": "界面已启动", "en": "GUI started"},
    "argparse_desc": {
        "zh": "OpenClaw 快速配置图形界面",
        "en": "OpenClaw Quick Config GUI",
    },
    "argparse_help_config": {"zh": "openclaw.json 路径", "en": "Path to openclaw.json"},
    "title_info": {"zh": "提示", "en": "Info"},
    "msg_busy": {
        "zh": "有任务正在执行，请稍候。",
        "en": "A task is running, please wait.",
    },
    "status_running_generic": {"zh": "处理中", "en": "Processing"},
    "status_running_save": {"zh": "正在保存配置", "en": "Saving configuration"},
    "status_running_primary": {"zh": "正在设置默认模型", "en": "Setting primary model"},
    "status_running_probe": {"zh": "正在探测模型", "en": "Probing models"},
    "status_running_gateway": {"zh": "正在重启网关", "en": "Restarting gateway"},
    "status_running_gateway_refresh": {
        "zh": "正在刷新网关状态",
        "en": "Refreshing gateway status",
    },
    "status_running_gateway_start_service": {
        "zh": "正在后台启动网关",
        "en": "Starting gateway service",
    },
    "status_running_gateway_start_window": {
        "zh": "正在当前窗口启动网关",
        "en": "Starting gateway in this window",
    },
    "status_running_gateway_stop": {
        "zh": "正在关闭网关",
        "en": "Stopping gateway",
    },
    "status_running_test": {"zh": "正在测试模型", "en": "Testing model"},
    "label_gateway_panel": {"zh": "网关状态监听", "en": "Gateway Monitor"},
    "label_gateway_state": {"zh": "状态", "en": "State"},
    "label_gateway_detail": {"zh": "详情", "en": "Details"},
    "gateway_state_unknown": {"zh": "未知", "en": "Unknown"},
    "gateway_state_checking": {"zh": "检查中", "en": "Checking"},
    "gateway_state_running_service": {
        "zh": "运行中（后台服务）",
        "en": "Running (service)",
    },
    "gateway_state_running_window": {
        "zh": "运行中（当前窗口）",
        "en": "Running (this window)",
    },
    "gateway_state_stopped": {"zh": "已停止", "en": "Stopped"},
    "gateway_state_error": {"zh": "异常", "en": "Error"},
    "check_gateway_auto_monitor": {"zh": "自动监听", "en": "Auto Monitor"},
    "btn_gateway_refresh": {"zh": "立即刷新", "en": "Refresh Now"},
    "btn_gateway_start_service": {"zh": "后台持久化启动", "en": "Start Service"},
    "btn_gateway_start_window": {"zh": "当前窗口启动", "en": "Start In Window"},
    "btn_gateway_stop": {"zh": "关闭网关", "en": "Stop Gateway"},
    "msg_gateway_started_service": {
        "zh": "已执行后台持久化启动。",
        "en": "Service start executed.",
    },
    "msg_gateway_started_window": {
        "zh": "已在当前窗口启动网关。",
        "en": "Gateway started in current window.",
    },
    "msg_gateway_stopped": {
        "zh": "已执行网关关闭。",
        "en": "Gateway stop executed.",
    },
    "msg_gateway_window_already": {
        "zh": "当前窗口网关已在运行。",
        "en": "Gateway is already running in this window.",
    },
    "label_test_panel": {"zh": "模型测试", "en": "Model Test"},
    "label_test_prompt": {"zh": "测试提示词", "en": "Prompt"},
    "label_test_tokens": {"zh": "输出 Tokens", "en": "Output Tokens"},
    "btn_test_model": {"zh": "测试当前模型", "en": "Test Current Model"},
    "label_command_panel": {"zh": "指令复制区", "en": "Command Copy Area"},
    "label_command_category": {"zh": "指令分类", "en": "Category"},
    "label_command_select": {"zh": "常用指令", "en": "Command Template"},
    "btn_copy_command": {"zh": "复制当前指令", "en": "Copy Command"},
    "btn_copy_all_commands": {"zh": "复制指令大全", "en": "Copy All"},
    "msg_copied_command": {"zh": "已复制当前指令", "en": "Command copied"},
    "msg_copied_all": {"zh": "已复制指令大全", "en": "All commands copied"},
    "msg_copy_failed": {"zh": "复制失败: {error}", "en": "Copy failed: {error}"},
    "category_all": {"zh": "全部", "en": "All"},
    "category_model": {"zh": "模型切换", "en": "Model Switching"},
    "category_gateway": {"zh": "网关运维", "en": "Gateway Ops"},
    "category_diagnostic": {"zh": "诊断校验", "en": "Diagnostics"},
    "category_chat": {"zh": "聊天指令", "en": "Chat Prompts"},
    "cmd_switch_primary": {"zh": "切换默认模型", "en": "Switch primary model"},
    "cmd_show_primary": {"zh": "查看当前默认模型", "en": "Show current primary"},
    "cmd_list_provider": {"zh": "查看当前提供商模型列表", "en": "List provider models"},
    "cmd_probe": {"zh": "模型可用性探测", "en": "Probe model availability"},
    "cmd_restart_gateway": {
        "zh": "重启网关并查看状态",
        "en": "Restart gateway + status",
    },
    "cmd_show_provider": {"zh": "查看当前提供商配置", "en": "Show provider config"},
    "cmd_tool_set_primary": {"zh": "用工具切换默认模型", "en": "Switch model via tool"},
    "cmd_chat_switch": {
        "zh": "给 AI 的切模指令模板",
        "en": "Chat prompt for model switch",
    },
    "title_test": {"zh": "模型测试", "en": "Model Test"},
    "title_test_failed": {"zh": "模型测试失败", "en": "Model Test Failed"},
    "default_test_prompt": {"zh": "请只回复: ok", "en": "Reply with: ok"},
    "msg_test_missing": {
        "zh": "请先填写以下字段: {fields}",
        "en": "Please fill required fields first: {fields}",
    },
    "msg_test_bad_tokens": {
        "zh": "输出 Tokens 必须是正整数",
        "en": "Output tokens must be a positive integer",
    },
    "msg_test_success": {
        "zh": "测试成功\n模型: {model_ref}\n耗时: {latency_ms} ms\n\n输出:\n{preview}",
        "en": "Test succeeded\nModel: {model_ref}\nLatency: {latency_ms} ms\n\nOutput:\n{preview}",
    },
    "msg_test_failed": {
        "zh": "测试失败\n模型: {model_ref}\n状态码: {status}\n错误: {error}\n\n返回:\n{preview}",
        "en": "Test failed\nModel: {model_ref}\nStatus: {status}\nError: {error}\n\nResponse:\n{preview}",
    },
    "wizard_title": {"zh": "新增模型向导", "en": "New Model Wizard"},
    "wizard_step": {"zh": "步骤 {index}/3", "en": "Step {index}/3"},
    "wizard_s1_title": {"zh": "1. 渠道信息", "en": "1. Provider"},
    "wizard_s2_title": {"zh": "2. 模型信息", "en": "2. Model"},
    "wizard_s3_title": {"zh": "3. 策略与验证", "en": "3. Policy & Verify"},
    "wizard_provider_hint": {"zh": "提供商 ID", "en": "Provider ID"},
    "wizard_base_url_hint": {"zh": "基础地址", "en": "Base URL"},
    "wizard_api_key_hint": {"zh": "API 密钥", "en": "API Key"},
    "wizard_api_mode_hint": {"zh": "API 模式", "en": "API Mode"},
    "wizard_model_id_hint": {"zh": "模型 ID", "en": "Model ID"},
    "wizard_model_name_hint": {"zh": "模型名称", "en": "Model Name"},
    "wizard_inputs_hint": {"zh": "输入类型（text,image）", "en": "Inputs (text,image)"},
    "wizard_context_hint": {"zh": "上下文窗口", "en": "Context Window"},
    "wizard_tokens_hint": {"zh": "最大 Tokens", "en": "Max Tokens"},
    "wizard_headers_hint": {
        "zh": "请求头（每行 KEY=VALUE）",
        "en": "Headers (KEY=VALUE per line)",
    },
    "wizard_fallback_hint": {
        "zh": "备用模型（逗号分隔 provider/model）",
        "en": "Fallbacks (comma-separated provider/model)",
    },
    "wizard_prev": {"zh": "上一步", "en": "Back"},
    "wizard_next": {"zh": "下一步", "en": "Next"},
    "wizard_finish": {"zh": "完成并保存", "en": "Finish & Save"},
    "wizard_cancel": {"zh": "取消", "en": "Cancel"},
}


def _resolve_cli_script_path() -> pathlib.Path:
    if getattr(sys, "frozen", False):
        meipass = pathlib.Path(
            getattr(sys, "_MEIPASS", pathlib.Path(sys.executable).parent)
        )
        bundled = meipass / "openclaw_quick_config.py"
        if bundled.exists():
            return bundled

    return pathlib.Path(__file__).with_name("openclaw_quick_config.py")


def _resolve_openclaw_executable() -> str:
    env_value = os.environ.get("OPENCLAW_BIN", "").strip()
    if env_value:
        env_path = pathlib.Path(env_value).expanduser()
        if env_path.exists():
            return str(env_path)

    discovered = shutil.which("openclaw")
    if discovered:
        return discovered

    candidates = [
        pathlib.Path.home() / ".local" / "bin" / "openclaw",
        pathlib.Path.home() / ".volta" / "bin" / "openclaw",
        pathlib.Path.home() / "Library" / "pnpm" / "openclaw",
        pathlib.Path("/opt/homebrew/bin/openclaw"),
        pathlib.Path("/usr/local/bin/openclaw"),
        pathlib.Path("/usr/bin/openclaw"),
    ]

    nvm_root = pathlib.Path.home() / ".nvm" / "versions" / "node"
    if nvm_root.exists():
        nvm_bins = sorted(nvm_root.glob("*/bin/openclaw"), reverse=True)
        candidates.extend(nvm_bins)

    if os.name == "nt":
        candidates.extend(
            [
                pathlib.Path.home()
                / "AppData"
                / "Local"
                / "Programs"
                / "openclaw"
                / "openclaw.exe",
                pathlib.Path("C:/Program Files/openclaw/openclaw.exe"),
            ]
        )

    for candidate in candidates:
        if candidate.exists():
            return str(candidate)

    raise FileNotFoundError(
        "openclaw command not found; set OPENCLAW_BIN or add openclaw to PATH"
    )


class QuickConfigGUI:
    def __init__(
        self, root: Any, config_path: pathlib.Path, cli_script: pathlib.Path
    ) -> None:
        self.root = root
        self.language_code = "zh"
        self.root.title(self._t("app_title"))
        self.root.geometry("1280x820")

        self.config_path_var = tk.StringVar(value=str(config_path))
        self.primary_var = tk.StringVar(value="-")
        self.status_var = tk.StringVar(value=self._t("status_ready"))
        self.language_display_var = tk.StringVar(value="中文")

        self.cli_script = cli_script

        self.provider_var = tk.StringVar()
        self.base_url_var = tk.StringVar()
        self.api_var = tk.StringVar(value="openai-completions")
        self.api_key_var = tk.StringVar()
        self.model_id_var = tk.StringVar()
        self.model_name_var = tk.StringVar()
        self.inputs_var = tk.StringVar(value="text")
        self.context_window_var = tk.StringVar(value="200000")
        self.max_tokens_var = tk.StringVar(value="8192")
        self.reasoning_var = tk.BooleanVar(value=False)
        self.auth_header_var = tk.BooleanVar(value=True)
        self.set_primary_var = tk.BooleanVar(value=True)
        self.restart_gateway_var = tk.BooleanVar(value=False)
        self.probe_after_write_var = tk.BooleanVar(value=True)
        self.primary_ref_var = tk.StringVar()
        self.fallbacks_var = tk.StringVar()
        self.test_max_tokens_var = tk.StringVar(value="64")
        self.gateway_state_var = tk.StringVar(value=self._t("gateway_state_unknown"))
        self.gateway_detail_var = tk.StringVar(value="-")
        self.gateway_auto_monitor_var = tk.BooleanVar(value=True)
        self.command_category_var = tk.StringVar()
        self.command_choice_var = tk.StringVar()
        self.command_category_select: Any = None

        self.providers_cache: Dict[str, dict] = {}
        self._widget_texts: Dict[str, Any] = {}
        self._action_widgets: List[Any] = []
        self._command_specs: List[Dict[str, str]] = []
        self._visible_command_specs: List[Dict[str, str]] = []
        self._command_category_label_to_id: Dict[str, str] = {}
        self._command_label_to_id: Dict[str, str] = {}
        self._busy = False
        self._busy_label_text = ""
        self._busy_tick = 0
        self._busy_after_id: Optional[str] = None
        self._gateway_state_key = "gateway_state_unknown"
        self._gateway_monitor_after_id: Optional[str] = None
        self._gateway_monitor_busy = False
        self._gateway_fg_process: Any = None

        self._build_ui()
        self.refresh_all()
        self._gateway_poll_once(log_command=False)

    def _t(self, key: str, **kwargs: Any) -> str:
        lang = "en" if self.language_code == "en" else "zh"
        template = I18N.get(key, {}).get(lang, key)
        if kwargs:
            return template.format(**kwargs)
        return template

    def _set_widget_texts(self) -> None:
        self.root.title(self._t("app_title"))

        for key, widget in self._widget_texts.items():
            widget.configure(text=self._t(key))

        self.language_display_var.set(
            "English" if self.language_code == "en" else "中文"
        )
        self._set_gateway_state(self._gateway_state_key, self.gateway_detail_var.get())

    def _on_language_change(self, _event: object = None) -> None:
        selected = self.language_display_var.get()
        self.language_code = "en" if selected == "English" else "zh"
        self._set_widget_texts()
        self._refresh_command_choices()

    def _build_command_specs(self) -> List[Dict[str, str]]:
        return [
            {
                "id": "switch_primary",
                "category": "model",
                "label_key": "cmd_switch_primary",
                "template": 'openclaw config set agents.defaults.model.primary "{model_ref}"',
            },
            {
                "id": "show_primary",
                "category": "model",
                "label_key": "cmd_show_primary",
                "template": "openclaw config get agents.defaults.model",
            },
            {
                "id": "list_provider",
                "category": "diagnostic",
                "label_key": "cmd_list_provider",
                "template": "openclaw models list --provider {provider} --all",
            },
            {
                "id": "probe_models",
                "category": "diagnostic",
                "label_key": "cmd_probe",
                "template": "openclaw models status --probe",
            },
            {
                "id": "restart_gateway",
                "category": "gateway",
                "label_key": "cmd_restart_gateway",
                "template": "openclaw gateway restart && openclaw gateway status --json",
            },
            {
                "id": "show_provider",
                "category": "diagnostic",
                "label_key": "cmd_show_provider",
                "template": "openclaw config get models.providers.{provider}",
            },
            {
                "id": "tool_set_primary",
                "category": "model",
                "label_key": "cmd_tool_set_primary",
                "template": 'python3 "{tool_path}" set-primary --model-ref "{model_ref}" --probe',
            },
            {
                "id": "chat_switch",
                "category": "chat",
                "label_key": "cmd_chat_switch",
                "template": "请把 OpenClaw 默认模型切换到 {model_ref}，并执行 openclaw config get agents.defaults.model 校验。",
            },
        ]

    def _command_context(self) -> Dict[str, str]:
        provider = self.provider_var.get().strip() or "<provider>"
        model = self.model_id_var.get().strip() or "<model>"
        desktop_tool = (
            pathlib.Path.home()
            / "Desktop"
            / "OpenClaw-Quick-Config-Tool"
            / "openclaw_quick_config.py"
        )
        tool_path = (
            desktop_tool
            if desktop_tool.exists()
            else pathlib.Path(__file__).with_name("openclaw_quick_config.py")
        )
        return {
            "provider": provider,
            "model": model,
            "model_ref": f"{provider}/{model}",
            "tool_path": str(tool_path),
        }

    def _render_command_text(self, command_id: str) -> str:
        context = self._command_context()
        for spec in self._command_specs:
            if spec.get("id") == command_id:
                template = str(spec.get("template", ""))
                try:
                    return template.format(**context)
                except Exception:
                    return template
        return ""

    def _set_command_preview(self, text: str) -> None:
        self.command_preview_text.configure(state="normal")
        self.command_preview_text.delete("1.0", tk.END)
        self.command_preview_text.insert("1.0", text)
        self.command_preview_text.configure(state="disabled")

    def _refresh_command_categories(self) -> None:
        options = [
            ("all", self._t("category_all")),
            ("model", self._t("category_model")),
            ("gateway", self._t("category_gateway")),
            ("diagnostic", self._t("category_diagnostic")),
            ("chat", self._t("category_chat")),
        ]

        labels = [label for _, label in options]
        self._command_category_label_to_id = {
            label: category_id for category_id, label in options
        }
        self.command_category_select.configure(values=labels)

        current = self.command_category_var.get().strip()
        if current not in labels and labels:
            self.command_category_var.set(labels[0])

    def _on_command_category_change(self, _event: object = None) -> None:
        self._refresh_command_choices()

    def _refresh_command_choices(self) -> None:
        self._refresh_command_categories()

        selected_category_label = self.command_category_var.get().strip()
        selected_category_id = self._command_category_label_to_id.get(
            selected_category_label,
            "all",
        )

        if selected_category_id == "all":
            filtered_specs = list(self._command_specs)
        else:
            filtered_specs = [
                spec
                for spec in self._command_specs
                if str(spec.get("category", "")) == selected_category_id
            ]

        self._visible_command_specs = filtered_specs

        labels: List[str] = []
        self._command_label_to_id = {}
        for spec in filtered_specs:
            label = self._t(str(spec.get("label_key", "")))
            labels.append(label)
            self._command_label_to_id[label] = str(spec.get("id", ""))

        self.command_select.configure(values=labels)

        current = self.command_choice_var.get().strip()
        if current not in labels and labels:
            self.command_choice_var.set(labels[0])

        self._refresh_command_preview()

    def _refresh_command_preview(self, _event: object = None) -> None:
        label = self.command_choice_var.get().strip()
        command_id = self._command_label_to_id.get(label, "")
        text = self._render_command_text(command_id)
        self._set_command_preview(text)

    def _copy_current_command(self) -> None:
        try:
            text = self.command_preview_text.get("1.0", tk.END).strip()
            if not text:
                return
            self.root.clipboard_clear()
            self.root.clipboard_append(text)
            self._set_status(self._t("msg_copied_command"), ok=True)
        except Exception as exc:
            self._set_status(self._t("msg_copy_failed", error=exc), ok=False)

    def _copy_all_commands(self) -> None:
        try:
            specs = self._visible_command_specs or self._command_specs
            lines: List[str] = []
            for spec in specs:
                label = self._t(str(spec.get("label_key", "")))
                command_text = self._render_command_text(str(spec.get("id", "")))
                lines.append(f"# {label}\n{command_text}")
            full_text = "\n\n".join(lines).strip()
            if not full_text:
                return
            self.root.clipboard_clear()
            self.root.clipboard_append(full_text)
            self._set_status(self._t("msg_copied_all"), ok=True)
        except Exception as exc:
            self._set_status(self._t("msg_copy_failed", error=exc), ok=False)

    def _build_ui(self) -> None:
        self.root.columnconfigure(0, weight=1)
        self.root.rowconfigure(1, weight=1)
        self.root.rowconfigure(2, weight=1)

        top = ttk.Frame(self.root, padding=10)
        top.grid(row=0, column=0, sticky="ew")
        top.columnconfigure(1, weight=1)
        top.columnconfigure(6, weight=1)

        self.lbl_config = ttk.Label(top, text="")
        self.lbl_config.grid(row=0, column=0, sticky="w")
        ttk.Entry(top, textvariable=self.config_path_var).grid(
            row=0, column=1, sticky="ew", padx=(6, 6)
        )
        self.btn_browse = ttk.Button(top, text="", command=self._browse_config)
        self.btn_browse.grid(row=0, column=2, padx=(0, 6))
        self.btn_refresh = ttk.Button(top, text="", command=self.refresh_all)
        self.btn_refresh.grid(row=0, column=3, padx=(0, 12))

        self.lbl_primary = ttk.Label(top, text="")
        self.lbl_primary.grid(row=0, column=4, sticky="w")
        ttk.Label(top, textvariable=self.primary_var).grid(
            row=0, column=5, sticky="w", padx=(6, 0)
        )
        self.lbl_status = ttk.Label(
            top, textvariable=self.status_var, foreground="#2e7d32"
        )
        self.lbl_status.grid(row=0, column=6, sticky="e")

        self.lbl_language = ttk.Label(top, text="")
        self.lbl_language.grid(row=0, column=7, sticky="e", padx=(8, 6))
        self.cmb_language = ttk.Combobox(
            top,
            textvariable=self.language_display_var,
            values=["中文", "English"],
            state="readonly",
            width=10,
        )
        self.cmb_language.grid(row=0, column=8, sticky="e")
        self.cmb_language.bind("<<ComboboxSelected>>", self._on_language_change)

        self.progress = ttk.Progressbar(top, mode="indeterminate")
        self.progress.grid(row=1, column=0, columnspan=9, sticky="ew", pady=(8, 0))
        self.progress.grid_remove()

        self._widget_texts.update(
            {
                "label_config": self.lbl_config,
                "btn_browse": self.btn_browse,
                "btn_refresh": self.btn_refresh,
                "label_primary": self.lbl_primary,
                "label_language": self.lbl_language,
            }
        )

        self._action_widgets.extend(
            [
                self.btn_browse,
                self.btn_refresh,
                self.cmb_language,
            ]
        )

        paned = ttk.Panedwindow(self.root, orient=tk.HORIZONTAL)
        paned.grid(row=1, column=0, sticky="nsew", padx=10, pady=(0, 10))

        left = ttk.Frame(paned, padding=8)
        left.columnconfigure(0, weight=1)
        left.rowconfigure(1, weight=1)
        left.rowconfigure(3, weight=1)

        self.lbl_providers = ttk.Label(left, text="")
        self.lbl_providers.grid(row=0, column=0, sticky="w")
        self.providers_list = tk.Listbox(left, exportselection=False)
        self.providers_list.grid(row=1, column=0, sticky="nsew", pady=(4, 8))
        self.providers_list.bind("<<ListboxSelect>>", self._on_provider_select)

        self.lbl_models = ttk.Label(left, text="")
        self.lbl_models.grid(row=2, column=0, sticky="w")
        self.models_list = tk.Listbox(left, exportselection=False)
        self.models_list.grid(row=3, column=0, sticky="nsew", pady=(4, 0))
        self.models_list.bind("<<ListboxSelect>>", self._on_model_select)

        self._action_widgets.extend([self.providers_list, self.models_list])

        self._widget_texts.update(
            {
                "provider_list": self.lbl_providers,
                "model_list": self.lbl_models,
            }
        )

        paned.add(left, weight=1)

        right = ttk.Frame(paned, padding=8)
        right.columnconfigure(1, weight=1)
        right.columnconfigure(3, weight=1)

        r = 0
        self.lbl_provider_id = ttk.Label(right, text="")
        self.lbl_provider_id.grid(row=r, column=0, sticky="w")
        ttk.Entry(right, textvariable=self.provider_var).grid(
            row=r, column=1, sticky="ew", padx=(6, 10)
        )
        self.lbl_api_mode = ttk.Label(right, text="")
        self.lbl_api_mode.grid(row=r, column=2, sticky="w")
        self.api_combo = ttk.Combobox(
            right,
            textvariable=self.api_var,
            values=["openai-completions", "openai-responses"],
            state="readonly",
        )
        self.api_combo.grid(row=r, column=3, sticky="ew", padx=(6, 0))
        self._action_widgets.append(self.api_combo)

        r += 1
        self.lbl_base_url = ttk.Label(right, text="")
        self.lbl_base_url.grid(row=r, column=0, sticky="w", pady=(8, 0))
        ttk.Entry(right, textvariable=self.base_url_var).grid(
            row=r, column=1, columnspan=3, sticky="ew", padx=(6, 0), pady=(8, 0)
        )

        r += 1
        self.lbl_api_key = ttk.Label(right, text="")
        self.lbl_api_key.grid(row=r, column=0, sticky="w", pady=(8, 0))
        ttk.Entry(right, textvariable=self.api_key_var, show="*").grid(
            row=r, column=1, columnspan=3, sticky="ew", padx=(6, 0), pady=(8, 0)
        )

        r += 1
        self.lbl_model_id = ttk.Label(right, text="")
        self.lbl_model_id.grid(row=r, column=0, sticky="w", pady=(8, 0))
        ttk.Entry(right, textvariable=self.model_id_var).grid(
            row=r, column=1, sticky="ew", padx=(6, 10), pady=(8, 0)
        )
        self.lbl_model_name = ttk.Label(right, text="")
        self.lbl_model_name.grid(row=r, column=2, sticky="w", pady=(8, 0))
        ttk.Entry(right, textvariable=self.model_name_var).grid(
            row=r, column=3, sticky="ew", padx=(6, 0), pady=(8, 0)
        )

        r += 1
        self.lbl_inputs = ttk.Label(right, text="")
        self.lbl_inputs.grid(row=r, column=0, sticky="w", pady=(8, 0))
        ttk.Entry(right, textvariable=self.inputs_var).grid(
            row=r, column=1, sticky="ew", padx=(6, 10), pady=(8, 0)
        )
        self.lbl_context_window = ttk.Label(right, text="")
        self.lbl_context_window.grid(row=r, column=2, sticky="w", pady=(8, 0))
        ttk.Entry(right, textvariable=self.context_window_var).grid(
            row=r, column=3, sticky="ew", padx=(6, 0), pady=(8, 0)
        )

        r += 1
        self.lbl_max_tokens = ttk.Label(right, text="")
        self.lbl_max_tokens.grid(row=r, column=0, sticky="w", pady=(8, 0))
        ttk.Entry(right, textvariable=self.max_tokens_var).grid(
            row=r, column=1, sticky="ew", padx=(6, 10), pady=(8, 0)
        )
        self.chk_reasoning = ttk.Checkbutton(
            right, text="", variable=self.reasoning_var
        )
        self.chk_reasoning.grid(row=r, column=2, sticky="w", pady=(8, 0))
        self.chk_auth_header = ttk.Checkbutton(
            right, text="", variable=self.auth_header_var
        )
        self.chk_auth_header.grid(row=r, column=3, sticky="w", pady=(8, 0))

        r += 1
        self.lbl_headers = ttk.Label(right, text="")
        self.lbl_headers.grid(row=r, column=0, sticky="nw", pady=(8, 0))
        self.headers_text = scrolledtext.ScrolledText(right, height=5)
        self.headers_text.grid(
            row=r, column=1, columnspan=3, sticky="ew", padx=(6, 0), pady=(8, 0)
        )

        r += 1
        self.lbl_fallbacks = ttk.Label(right, text="")
        self.lbl_fallbacks.grid(row=r, column=0, sticky="w", pady=(8, 0))
        ttk.Entry(right, textvariable=self.fallbacks_var).grid(
            row=r, column=1, columnspan=3, sticky="ew", padx=(6, 0), pady=(8, 0)
        )

        r += 1
        options = ttk.Frame(right)
        options.grid(row=r, column=0, columnspan=4, sticky="w", pady=(8, 0))
        self.chk_set_primary = ttk.Checkbutton(
            options, text="", variable=self.set_primary_var
        )
        self.chk_set_primary.pack(side=tk.LEFT)
        self.chk_restart_gateway = ttk.Checkbutton(
            options,
            text="",
            variable=self.restart_gateway_var,
        )
        self.chk_restart_gateway.pack(side=tk.LEFT, padx=(16, 0))
        self.chk_probe_after = ttk.Checkbutton(
            options, text="", variable=self.probe_after_write_var
        )
        self.chk_probe_after.pack(side=tk.LEFT, padx=(16, 0))

        r += 1
        actions = ttk.Frame(right)
        actions.grid(row=r, column=0, columnspan=4, sticky="ew", pady=(10, 0))
        actions.columnconfigure(0, weight=1)
        actions.columnconfigure(1, weight=1)
        actions.columnconfigure(2, weight=1)
        actions.columnconfigure(3, weight=1)
        actions.columnconfigure(4, weight=1)

        self.btn_wizard = ttk.Button(actions, text="", command=self._open_model_wizard)
        self.btn_wizard.grid(row=0, column=0, sticky="ew", padx=(0, 6))
        self.btn_upsert = ttk.Button(
            actions, text="", command=self._upsert_provider_model
        )
        self.btn_upsert.grid(row=0, column=1, sticky="ew", padx=(0, 6))
        self.btn_set_primary = ttk.Button(actions, text="", command=self._set_primary)
        self.btn_set_primary.grid(row=0, column=2, sticky="ew", padx=(0, 6))
        self.btn_probe = ttk.Button(actions, text="", command=self._probe_models)
        self.btn_probe.grid(row=0, column=3, sticky="ew", padx=(0, 6))
        self.btn_restart_gateway = ttk.Button(
            actions, text="", command=self._restart_gateway
        )
        self.btn_restart_gateway.grid(row=0, column=4, sticky="ew")

        self._action_widgets.extend(
            [
                self.chk_set_primary,
                self.chk_restart_gateway,
                self.chk_probe_after,
                self.btn_wizard,
                self.btn_upsert,
                self.btn_set_primary,
                self.btn_probe,
                self.btn_restart_gateway,
            ]
        )

        r += 1
        self.lbl_primary_ref = ttk.Label(right, text="")
        self.lbl_primary_ref.grid(row=r, column=0, sticky="w", pady=(8, 0))
        ttk.Entry(right, textvariable=self.primary_ref_var).grid(
            row=r, column=1, columnspan=3, sticky="ew", padx=(6, 0), pady=(8, 0)
        )

        r += 1
        self.test_frame = ttk.LabelFrame(right, text="")
        self.test_frame.grid(row=r, column=0, columnspan=4, sticky="nsew", pady=(10, 0))
        self.test_frame.columnconfigure(1, weight=1)

        self.lbl_test_prompt = ttk.Label(self.test_frame, text="")
        self.lbl_test_prompt.grid(
            row=0, column=0, sticky="nw", padx=(8, 8), pady=(8, 8)
        )
        self.test_prompt_text = scrolledtext.ScrolledText(self.test_frame, height=4)
        self.test_prompt_text.grid(
            row=0, column=1, sticky="ew", padx=(0, 8), pady=(8, 8)
        )
        self.test_prompt_text.insert("1.0", self._t("default_test_prompt"))

        self.lbl_test_tokens = ttk.Label(self.test_frame, text="")
        self.lbl_test_tokens.grid(row=1, column=0, sticky="w", padx=(8, 8), pady=(0, 8))
        ttk.Entry(
            self.test_frame, textvariable=self.test_max_tokens_var, width=12
        ).grid(row=1, column=1, sticky="w", padx=(0, 8), pady=(0, 8))

        self.btn_test_model = ttk.Button(
            self.test_frame, text="", command=self._test_current_model
        )
        self.btn_test_model.grid(row=1, column=1, sticky="e", padx=(0, 8), pady=(0, 8))

        self._action_widgets.append(self.btn_test_model)

        r += 1
        self.command_frame = ttk.LabelFrame(right, text="")
        self.command_frame.grid(
            row=r, column=0, columnspan=4, sticky="nsew", pady=(10, 0)
        )
        self.command_frame.columnconfigure(1, weight=1)

        self.lbl_command_category = ttk.Label(self.command_frame, text="")
        self.lbl_command_category.grid(
            row=0, column=0, sticky="w", padx=(8, 8), pady=(8, 8)
        )
        self.command_category_select = ttk.Combobox(
            self.command_frame,
            textvariable=self.command_category_var,
            state="readonly",
        )
        self.command_category_select.grid(
            row=0, column=1, sticky="ew", padx=(0, 8), pady=(8, 8)
        )
        self.command_category_select.bind(
            "<<ComboboxSelected>>",
            self._on_command_category_change,
        )

        self.lbl_command_select = ttk.Label(self.command_frame, text="")
        self.lbl_command_select.grid(
            row=1, column=0, sticky="w", padx=(8, 8), pady=(0, 8)
        )
        self.command_select = ttk.Combobox(
            self.command_frame,
            textvariable=self.command_choice_var,
            state="readonly",
        )
        self.command_select.grid(row=1, column=1, sticky="ew", padx=(0, 8), pady=(0, 8))
        self.command_select.bind("<<ComboboxSelected>>", self._refresh_command_preview)

        self.command_preview_text = scrolledtext.ScrolledText(
            self.command_frame, height=6
        )
        self.command_preview_text.grid(
            row=2, column=0, columnspan=2, sticky="nsew", padx=8, pady=(0, 8)
        )
        self.command_preview_text.configure(state="disabled")

        command_actions = ttk.Frame(self.command_frame)
        command_actions.grid(
            row=3, column=0, columnspan=2, sticky="e", padx=8, pady=(0, 8)
        )
        self.btn_copy_command = ttk.Button(
            command_actions, text="", command=self._copy_current_command
        )
        self.btn_copy_command.grid(row=0, column=0, padx=(0, 8))
        self.btn_copy_all_commands = ttk.Button(
            command_actions, text="", command=self._copy_all_commands
        )
        self.btn_copy_all_commands.grid(row=0, column=1)

        self._action_widgets.extend(
            [
                self.command_category_select,
                self.command_select,
                self.btn_copy_command,
                self.btn_copy_all_commands,
            ]
        )

        r += 1
        self.gateway_frame = ttk.LabelFrame(right, text="")
        self.gateway_frame.grid(
            row=r, column=0, columnspan=4, sticky="nsew", pady=(10, 0)
        )
        self.gateway_frame.columnconfigure(1, weight=1)

        self.lbl_gateway_state = ttk.Label(self.gateway_frame, text="")
        self.lbl_gateway_state.grid(
            row=0, column=0, sticky="w", padx=(8, 8), pady=(8, 6)
        )
        self.lbl_gateway_state_value = ttk.Label(
            self.gateway_frame,
            textvariable=self.gateway_state_var,
            foreground="#1565c0",
        )
        self.lbl_gateway_state_value.grid(
            row=0, column=1, sticky="w", padx=(0, 8), pady=(8, 6)
        )

        self.lbl_gateway_detail = ttk.Label(self.gateway_frame, text="")
        self.lbl_gateway_detail.grid(
            row=1, column=0, sticky="nw", padx=(8, 8), pady=(0, 8)
        )
        self.lbl_gateway_detail_value = ttk.Label(
            self.gateway_frame,
            textvariable=self.gateway_detail_var,
            justify="left",
            wraplength=620,
        )
        self.lbl_gateway_detail_value.grid(
            row=1, column=1, sticky="w", padx=(0, 8), pady=(0, 8)
        )

        gateway_actions = ttk.Frame(self.gateway_frame)
        gateway_actions.grid(
            row=2, column=0, columnspan=2, sticky="ew", padx=8, pady=(0, 8)
        )
        gateway_actions.columnconfigure(5, weight=1)

        self.chk_gateway_auto = ttk.Checkbutton(
            gateway_actions,
            text="",
            variable=self.gateway_auto_monitor_var,
            command=self._on_gateway_auto_monitor_change,
        )
        self.chk_gateway_auto.grid(row=0, column=0, padx=(0, 8), sticky="w")

        self.btn_gateway_refresh = ttk.Button(
            gateway_actions,
            text="",
            command=self._gateway_refresh_now,
        )
        self.btn_gateway_refresh.grid(row=0, column=1, padx=(0, 8), sticky="w")

        self.btn_gateway_start_service = ttk.Button(
            gateway_actions,
            text="",
            command=self._gateway_start_service,
        )
        self.btn_gateway_start_service.grid(row=0, column=2, padx=(0, 8), sticky="w")

        self.btn_gateway_start_window = ttk.Button(
            gateway_actions,
            text="",
            command=self._gateway_start_window,
        )
        self.btn_gateway_start_window.grid(row=0, column=3, padx=(0, 8), sticky="w")

        self.btn_gateway_stop = ttk.Button(
            gateway_actions,
            text="",
            command=self._gateway_stop,
        )
        self.btn_gateway_stop.grid(row=0, column=4, padx=(0, 8), sticky="w")

        self._action_widgets.extend(
            [
                self.chk_gateway_auto,
                self.btn_gateway_refresh,
                self.btn_gateway_start_service,
                self.btn_gateway_start_window,
                self.btn_gateway_stop,
            ]
        )

        self._widget_texts.update(
            {
                "label_provider_id": self.lbl_provider_id,
                "label_api_mode": self.lbl_api_mode,
                "label_base_url": self.lbl_base_url,
                "label_api_key": self.lbl_api_key,
                "label_model_id": self.lbl_model_id,
                "label_model_name": self.lbl_model_name,
                "label_inputs": self.lbl_inputs,
                "label_context_window": self.lbl_context_window,
                "label_max_tokens": self.lbl_max_tokens,
                "check_reasoning": self.chk_reasoning,
                "check_auth_header": self.chk_auth_header,
                "label_headers": self.lbl_headers,
                "label_fallbacks": self.lbl_fallbacks,
                "check_set_primary": self.chk_set_primary,
                "check_restart_gateway": self.chk_restart_gateway,
                "check_probe_after": self.chk_probe_after,
                "btn_wizard": self.btn_wizard,
                "btn_upsert": self.btn_upsert,
                "btn_set_primary": self.btn_set_primary,
                "btn_probe": self.btn_probe,
                "btn_restart_gateway": self.btn_restart_gateway,
                "label_primary_ref": self.lbl_primary_ref,
                "label_test_panel": self.test_frame,
                "label_test_prompt": self.lbl_test_prompt,
                "label_test_tokens": self.lbl_test_tokens,
                "btn_test_model": self.btn_test_model,
                "label_command_panel": self.command_frame,
                "label_command_category": self.lbl_command_category,
                "label_command_select": self.lbl_command_select,
                "btn_copy_command": self.btn_copy_command,
                "btn_copy_all_commands": self.btn_copy_all_commands,
                "label_gateway_panel": self.gateway_frame,
                "label_gateway_state": self.lbl_gateway_state,
                "label_gateway_detail": self.lbl_gateway_detail,
                "check_gateway_auto_monitor": self.chk_gateway_auto,
                "btn_gateway_refresh": self.btn_gateway_refresh,
                "btn_gateway_start_service": self.btn_gateway_start_service,
                "btn_gateway_start_window": self.btn_gateway_start_window,
                "btn_gateway_stop": self.btn_gateway_stop,
            }
        )

        paned.add(right, weight=2)

        log_frame = ttk.Frame(self.root, padding=(10, 0, 10, 10))
        log_frame.grid(row=2, column=0, sticky="nsew")
        log_frame.columnconfigure(0, weight=1)
        log_frame.rowconfigure(1, weight=1)

        self.lbl_log = ttk.Label(log_frame, text="")
        self.lbl_log.grid(row=0, column=0, sticky="w")
        self.log_text = scrolledtext.ScrolledText(log_frame, height=12)
        self.log_text.grid(row=1, column=0, sticky="nsew", pady=(4, 0))

        self._widget_texts.update(
            {
                "label_log": self.lbl_log,
            }
        )

        self._command_specs = self._build_command_specs()
        self._set_widget_texts()
        self._refresh_command_choices()

    def _log(self, text: str) -> None:
        self.log_text.insert(tk.END, text.rstrip() + "\n")
        self.log_text.see(tk.END)

    def _set_status(self, text: str, ok: bool = True) -> None:
        self.status_var.set(text)
        color = "#2e7d32" if ok else "#c62828"
        self.lbl_status.configure(foreground=color)

    def _set_gateway_state(self, state_key: str, detail: str = "-") -> None:
        self._gateway_state_key = state_key
        self.gateway_state_var.set(self._t(state_key))
        self.gateway_detail_var.set(detail or "-")

    def _is_gateway_window_running(self) -> bool:
        proc = self._gateway_fg_process
        return bool(proc is not None and proc.poll() is None)

    def _on_gateway_auto_monitor_change(self) -> None:
        if self.gateway_auto_monitor_var.get():
            self._gateway_poll_once(log_command=False)
        else:
            if self._gateway_monitor_after_id is not None:
                self.root.after_cancel(self._gateway_monitor_after_id)
                self._gateway_monitor_after_id = None

    def _schedule_gateway_monitor(self, delay_ms: int = 5000) -> None:
        if self._gateway_monitor_after_id is not None:
            self.root.after_cancel(self._gateway_monitor_after_id)
            self._gateway_monitor_after_id = None
        if not self.gateway_auto_monitor_var.get():
            return
        self._gateway_monitor_after_id = self.root.after(
            delay_ms,
            lambda: self._gateway_poll_once(log_command=False),
        )

    def _interpret_gateway_status_result(
        self, result: Dict[str, Any]
    ) -> Tuple[str, str]:
        if self._is_gateway_window_running():
            window_state = "gateway_state_running_window"
        else:
            window_state = ""

        code = int(result.get("code", 1))
        stdout_text = str(result.get("stdout", "")).strip()
        stderr_text = str(result.get("stderr", "")).strip()

        if code != 0:
            if window_state:
                return window_state, stderr_text or stdout_text or "-"
            return "gateway_state_error", stderr_text or stdout_text or "-"

        parsed: Any = {}
        with contextlib.suppress(Exception):
            parsed = json.loads(stdout_text)

        rpc_ok = False
        service_running = False
        detail_parts: List[str] = []

        if isinstance(parsed, dict):
            rpc = parsed.get("rpc", {})
            if isinstance(rpc, dict):
                rpc_ok = bool(rpc.get("ok"))
                detail_parts.append(f"rpc.ok={rpc.get('ok')}")

            service = parsed.get("service", {})
            if isinstance(service, dict):
                if "running" in service:
                    service_running = bool(service.get("running"))
                    detail_parts.append(f"service.running={service.get('running')}")
                elif "status" in service:
                    status_text = str(service.get("status", ""))
                    lowered = status_text.lower()
                    service_running = "running" in lowered and "not" not in lowered
                    detail_parts.append(f"service={status_text}")

            if "url" in parsed:
                detail_parts.append(f"url={parsed.get('url')}")

        if not service_running:
            lowered_stdout = stdout_text.lower()
            if "not running" in lowered_stdout or "stopped" in lowered_stdout:
                service_running = False
            elif "running" in lowered_stdout:
                service_running = True

        if window_state:
            state_key = window_state
        elif rpc_ok or service_running:
            state_key = "gateway_state_running_service"
        else:
            state_key = "gateway_state_stopped"

        detail = " | ".join(part for part in detail_parts if part).strip()
        if not detail:
            detail = stdout_text[:500] if stdout_text else "-"
        return state_key, detail

    def _gateway_poll_once(self, log_command: bool = False) -> None:
        if self._gateway_monitor_busy:
            return

        if self._busy and not log_command:
            self._schedule_gateway_monitor()
            return

        self._gateway_monitor_busy = True
        self._set_gateway_state("gateway_state_checking", self.gateway_detail_var.get())

        def runner() -> None:
            result = self._run_subprocess(
                ["openclaw", "gateway", "status", "--json"],
                timeout_seconds=12.0,
            )
            state_key, detail = self._interpret_gateway_status_result(result)

            def finish() -> None:
                self._gateway_monitor_busy = False
                if log_command:
                    self._emit_command_result(result)
                self._set_gateway_state(state_key, detail)
                self._schedule_gateway_monitor()

            self.root.after(0, finish)

        threading.Thread(target=runner, daemon=True).start()

    def _gateway_refresh_now(self) -> None:
        self._set_status(self._t("status_running_gateway_refresh"), ok=True)
        self._gateway_poll_once(log_command=True)

    def _gateway_start_service(self) -> None:
        def worker() -> List[Dict[str, Any]]:
            start_result = self._run_subprocess(
                ["openclaw", "gateway", "start"],
                timeout_seconds=25.0,
            )
            status_result = self._run_subprocess(
                ["openclaw", "gateway", "status", "--json"],
                timeout_seconds=12.0,
            )
            return [start_result, status_result]

        def on_done(results: List[Dict[str, Any]]) -> None:
            for item in results:
                self._emit_command_result(item)

            start_code = int(results[0].get("code", 1)) if results else 1
            status_result = results[-1] if results else {"code": 1, "stderr": "-"}
            state_key, detail = self._interpret_gateway_status_result(status_result)
            self._set_gateway_state(state_key, detail)

            if start_code == 0:
                self._set_status(self._t("status_cmd_ok"), ok=True)
                messagebox.showinfo(
                    self._t("title_gateway"),
                    self._t("msg_gateway_started_service"),
                )
            else:
                self._set_status(
                    self._t("status_cmd_failed", code=start_code), ok=False
                )
                messagebox.showerror(
                    self._t("title_gateway_failed"),
                    self._t("msg_cmd_failed", code=start_code),
                )

        self._run_async(
            self._t("status_running_gateway_start_service"), worker, on_done
        )

    def _gateway_start_window(self) -> None:
        if self._is_gateway_window_running():
            messagebox.showinfo(
                self._t("title_gateway"),
                self._t("msg_gateway_window_already"),
            )
            return

        def worker() -> Dict[str, Any]:
            openclaw_bin = _resolve_openclaw_executable()
            command = [openclaw_bin, "gateway", "run", "--force"]
            env = dict(os.environ)
            env["PATH"] = (
                f"{pathlib.Path(openclaw_bin).parent}{os.pathsep}{env.get('PATH', '')}"
            )

            proc = subprocess.Popen(
                command,
                stdout=subprocess.DEVNULL,
                stderr=subprocess.DEVNULL,
                env=env,
            )
            self._gateway_fg_process = proc
            time.sleep(0.8)

            running = proc.poll() is None
            return {
                "command": " ".join(shlex.quote(c) for c in command),
                "code": 0 if running else int(proc.poll() or 1),
                "stdout": "",
                "stderr": "" if running else "gateway process exited immediately",
                "pid": proc.pid,
            }

        def on_done(result: Dict[str, Any]) -> None:
            self._emit_command_result(result)
            code = int(result.get("code", 1))
            if code == 0:
                pid = result.get("pid", "-")
                self._set_gateway_state("gateway_state_running_window", f"pid={pid}")
                self._set_status(self._t("status_cmd_ok"), ok=True)
                messagebox.showinfo(
                    self._t("title_gateway"),
                    self._t("msg_gateway_started_window"),
                )
                self._schedule_gateway_monitor(1200)
            else:
                self._set_status(self._t("status_cmd_failed", code=code), ok=False)
                messagebox.showerror(
                    self._t("title_gateway_failed"),
                    self._t("msg_cmd_failed", code=code),
                )

        self._run_async(self._t("status_running_gateway_start_window"), worker, on_done)

    def _cleanup_gateway_window_process(self) -> None:
        proc = self._gateway_fg_process
        if proc is None:
            return
        if proc.poll() is None:
            with contextlib.suppress(Exception):
                proc.terminate()
                proc.wait(timeout=4.0)
            if proc.poll() is None:
                with contextlib.suppress(Exception):
                    proc.kill()
        self._gateway_fg_process = None

    def _gateway_stop(self) -> None:
        def worker() -> List[Dict[str, Any]]:
            results: List[Dict[str, Any]] = []

            if self._is_gateway_window_running():
                proc = self._gateway_fg_process
                if proc is not None:
                    with contextlib.suppress(Exception):
                        proc.terminate()
                        proc.wait(timeout=4.0)
                    if proc.poll() is None:
                        with contextlib.suppress(Exception):
                            proc.kill()
                    results.append(
                        {
                            "command": "foreground gateway stop",
                            "code": 0,
                            "stdout": "foreground process stopped",
                            "stderr": "",
                        }
                    )
                    self._gateway_fg_process = None

            stop_result = self._run_subprocess(
                ["openclaw", "gateway", "stop"],
                timeout_seconds=20.0,
            )
            results.append(stop_result)

            status_result = self._run_subprocess(
                ["openclaw", "gateway", "status", "--json"],
                timeout_seconds=12.0,
            )
            results.append(status_result)
            return results

        def on_done(results: List[Dict[str, Any]]) -> None:
            for item in results:
                self._emit_command_result(item)

            stop_code = 1
            for item in results:
                if str(item.get("command", "")).find("gateway stop") >= 0:
                    stop_code = int(item.get("code", 1))
                    break

            status_result = results[-1] if results else {"code": 1, "stderr": "-"}
            state_key, detail = self._interpret_gateway_status_result(status_result)
            self._set_gateway_state(state_key, detail)

            if stop_code == 0:
                self._set_status(self._t("status_cmd_ok"), ok=True)
                messagebox.showinfo(
                    self._t("title_gateway"),
                    self._t("msg_gateway_stopped"),
                )
            else:
                self._set_status(self._t("status_cmd_failed", code=stop_code), ok=False)
                messagebox.showerror(
                    self._t("title_gateway_failed"),
                    self._t("msg_cmd_failed", code=stop_code),
                )

        self._run_async(self._t("status_running_gateway_stop"), worker, on_done)

    def _on_window_close(self) -> None:
        if self._gateway_monitor_after_id is not None:
            self.root.after_cancel(self._gateway_monitor_after_id)
            self._gateway_monitor_after_id = None
        self._cleanup_gateway_window_process()
        self.root.destroy()

    def _set_controls_state(self, disabled: bool) -> None:
        state = "disabled" if disabled else "normal"
        for widget in self._action_widgets:
            with contextlib.suppress(Exception):
                if isinstance(widget, ttk.Combobox):
                    widget.configure(state="disabled" if disabled else "readonly")
                else:
                    widget.configure(state=state)

    def _animate_busy_status(self) -> None:
        if not self._busy:
            return

        frames = [".", "..", "..."]
        suffix = frames[self._busy_tick % len(frames)]
        self.status_var.set(f"{self._busy_label_text}{suffix}")
        self.lbl_status.configure(foreground="#1565c0")
        self._busy_tick += 1
        self._busy_after_id = self.root.after(280, self._animate_busy_status)

    def _start_busy(self, status_text: str) -> None:
        self._busy = True
        self._busy_label_text = status_text
        self._busy_tick = 0
        self._set_controls_state(True)
        self.progress.grid()
        self.progress.start(12)
        self._animate_busy_status()

    def _stop_busy(self) -> None:
        self._busy = False
        if self._busy_after_id is not None:
            self.root.after_cancel(self._busy_after_id)
            self._busy_after_id = None
        self.progress.stop()
        self.progress.grid_remove()
        self._set_controls_state(False)

    def _run_async(
        self,
        status_text: str,
        worker: Any,
        on_done: Any,
    ) -> None:
        if self._busy:
            messagebox.showinfo(self._t("title_info"), self._t("msg_busy"))
            return

        self._start_busy(status_text)

        def _runner() -> None:
            try:
                payload = worker()
                error: Optional[Exception] = None
                tb = ""
            except Exception as exc:  # noqa: BLE001
                payload = None
                error = exc
                tb = traceback.format_exc()

            def _finish() -> None:
                self._stop_busy()
                if error is not None:
                    self._set_status(self._t("status_cmd_failed", code=1), ok=False)
                    self._log(self._t("log_error", error=error))
                    if tb:
                        self._log(tb)
                    messagebox.showerror(self._t("title_error"), str(error))
                    return
                on_done(payload)

            self.root.after(0, _finish)

        threading.Thread(target=_runner, daemon=True).start()

    def _browse_config(self) -> None:
        chosen = filedialog.askopenfilename(
            title=self._t("dialog_select_config"),
            filetypes=[
                (self._t("filetype_json"), "*.json"),
                (self._t("filetype_all"), "*.*"),
            ],
        )
        if chosen:
            self.config_path_var.set(chosen)
            self.refresh_all()

    def _read_config(self) -> dict:
        path = pathlib.Path(self.config_path_var.get()).expanduser()
        with path.open("r", encoding="utf-8") as f:
            return json.load(f)

    def refresh_all(self) -> None:
        try:
            cfg = self._read_config()
        except Exception as exc:
            self._set_status(self._t("status_load_failed", error=exc), ok=False)
            self._log(self._t("log_load_failed", error=exc))
            return

        providers = cfg.get("models", {}).get("providers", {})
        primary = (
            cfg.get("agents", {})
            .get("defaults", {})
            .get("model", {})
            .get("primary", "-")
        )

        self.providers_cache = providers
        self.primary_var.set(primary)

        self.providers_list.delete(0, tk.END)
        for provider_id in sorted(providers.keys()):
            self.providers_list.insert(tk.END, provider_id)

        self.models_list.delete(0, tk.END)
        self._set_status(self._t("status_loaded"), ok=True)
        self._log(self._t("log_loaded"))
        self._refresh_command_choices()

    def _on_provider_select(self, _event: object) -> None:
        selection = self.providers_list.curselection()
        if not selection:
            return
        provider_id = self.providers_list.get(selection[0])
        provider = self.providers_cache.get(provider_id, {})

        self.provider_var.set(provider_id)
        self.base_url_var.set(provider.get("baseUrl", ""))
        self.api_var.set(provider.get("api", "openai-completions"))
        self.api_key_var.set(provider.get("apiKey", ""))
        self.auth_header_var.set(bool(provider.get("authHeader", False)))

        headers = provider.get("headers", {})
        self.headers_text.delete("1.0", tk.END)
        if isinstance(headers, dict):
            lines = [f"{k}={v}" for k, v in headers.items()]
            self.headers_text.insert(tk.END, "\n".join(lines))

        self.models_list.delete(0, tk.END)
        for model in provider.get("models", []):
            self.models_list.insert(tk.END, str(model.get("id", "")))

        if self.models_list.size() > 0:
            self.models_list.selection_set(0)
            self._on_model_select(None)
        else:
            self._refresh_command_preview()

    def _on_model_select(self, _event: object) -> None:
        p_sel = self.providers_list.curselection()
        m_sel = self.models_list.curselection()
        if not p_sel or not m_sel:
            return

        provider_id = self.providers_list.get(p_sel[0])
        model_id = self.models_list.get(m_sel[0])
        provider = self.providers_cache.get(provider_id, {})

        found: Optional[dict] = None
        for model in provider.get("models", []):
            if str(model.get("id", "")) == model_id:
                found = model
                break
        if found is None:
            return

        self.model_id_var.set(str(found.get("id", "")))
        self.model_name_var.set(str(found.get("name", "")))
        inputs = found.get("input", ["text"])
        if isinstance(inputs, list):
            self.inputs_var.set(",".join(str(v) for v in inputs))
        self.context_window_var.set(str(found.get("contextWindow", 200000)))
        self.max_tokens_var.set(str(found.get("maxTokens", 8192)))
        self.reasoning_var.set(bool(found.get("reasoning", False)))

        self.primary_ref_var.set(f"{provider_id}/{model_id}")
        self._refresh_command_preview()

    def _parse_headers_text(self) -> List[Tuple[str, str]]:
        raw = self.headers_text.get("1.0", tk.END)
        out: List[Tuple[str, str]] = []
        for line in raw.splitlines():
            line = line.strip()
            if not line:
                continue
            if "=" not in line:
                raise ValueError(self._t("err_header_line", line=line))
            k, v = line.split("=", 1)
            k = k.strip()
            if not k:
                raise ValueError(self._t("err_header_key", line=line))
            out.append((k, v.strip()))
        return out

    def _run_subprocess(
        self, command: List[str], timeout_seconds: Optional[float] = 35.0
    ) -> Dict[str, Any]:
        if not command:
            raise ValueError("command cannot be empty")

        resolved_path: Optional[str] = None
        if command[0] == "openclaw":
            resolved_path = _resolve_openclaw_executable()
            command = [resolved_path, *command[1:]]

        pretty = " ".join(shlex.quote(c) for c in command)

        env = dict(os.environ)
        if resolved_path:
            resolved_dir = str(pathlib.Path(resolved_path).parent)
            env["PATH"] = f"{resolved_dir}{os.pathsep}{env.get('PATH', '')}"

        try:
            result = subprocess.run(
                command,
                capture_output=True,
                text=True,
                check=False,
                env=env,
                timeout=timeout_seconds,
            )
        except subprocess.TimeoutExpired as exc:
            return {
                "command": pretty,
                "code": 124,
                "stdout": (exc.stdout or "").rstrip(),
                "stderr": (exc.stderr or "").rstrip()
                or f"timeout after {timeout_seconds}s",
            }

        return {
            "command": pretty,
            "code": int(result.returncode),
            "stdout": result.stdout.rstrip() if result.stdout else "",
            "stderr": result.stderr.rstrip() if result.stderr else "",
        }

    def _run_cli_module_command(
        self, command_name: str, args: Dict[str, Any]
    ) -> Dict[str, Any]:
        if command_name not in {"quick-add", "set-primary"}:
            raise ValueError(f"Unsupported command: {command_name}")

        spec = importlib.util.spec_from_file_location(
            "openclaw_quick_config_embedded",
            str(self.cli_script),
        )
        if spec is None or spec.loader is None:
            raise RuntimeError(f"Cannot load CLI script: {self.cli_script}")

        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)

        handler_name = (
            "_cmd_quick_add" if command_name == "quick-add" else "_cmd_set_primary"
        )
        handler = getattr(module, handler_name, None)
        if handler is None:
            raise RuntimeError(f"CLI handler not found: {handler_name}")

        namespace = argparse.Namespace(**args)
        stdout_buffer = io.StringIO()
        stderr_buffer = io.StringIO()
        previous_openclaw_bin = os.environ.get("OPENCLAW_BIN")
        resolved_openclaw_bin: Optional[str] = None
        with contextlib.suppress(Exception):
            resolved_openclaw_bin = _resolve_openclaw_executable()

        if resolved_openclaw_bin:
            os.environ["OPENCLAW_BIN"] = resolved_openclaw_bin

        try:
            with (
                contextlib.redirect_stdout(stdout_buffer),
                contextlib.redirect_stderr(stderr_buffer),
            ):
                result = handler(namespace)
        finally:
            if previous_openclaw_bin is None:
                os.environ.pop("OPENCLAW_BIN", None)
            else:
                os.environ["OPENCLAW_BIN"] = previous_openclaw_bin

        stdout_text = stdout_buffer.getvalue().strip()
        stderr_text = stderr_buffer.getvalue().strip()

        command_parts = [command_name]
        if command_name == "set-primary":
            command_parts.append(str(args.get("model_ref", "")))
        if command_name == "quick-add":
            command_parts.append(str(args.get("provider_id", "")))
            command_parts.append(str(args.get("model_id", "")))

        return {
            "command": " ".join(part for part in command_parts if part),
            "code": int(result),
            "stdout": stdout_text,
            "stderr": stderr_text,
        }

    def _emit_command_result(self, result: Dict[str, Any]) -> None:
        command = str(result.get("command", "")).strip()
        if command:
            self._log(f"$ {command}")

        stdout_text = str(result.get("stdout", "")).strip()
        stderr_text = str(result.get("stderr", "")).strip()
        if stdout_text:
            self._log(stdout_text)
        if stderr_text:
            self._log(stderr_text)

    def _extract_test_preview(self, api_mode: str, parsed: Any, raw: str) -> str:
        if isinstance(parsed, dict):
            if api_mode == "openai-responses":
                direct = parsed.get("output_text")
                if isinstance(direct, str) and direct.strip():
                    return direct.strip()[:1000]

                collected: List[str] = []
                output_items = parsed.get("output")
                if isinstance(output_items, list):
                    for item in output_items:
                        if not isinstance(item, dict):
                            continue
                        content_items = item.get("content")
                        if not isinstance(content_items, list):
                            continue
                        for part in content_items:
                            if isinstance(part, dict):
                                text_value = part.get("text")
                                if isinstance(text_value, str) and text_value.strip():
                                    collected.append(text_value.strip())
                if collected:
                    return "\n".join(collected)[:1000]

            choices = parsed.get("choices")
            if isinstance(choices, list) and choices:
                first = choices[0]
                if isinstance(first, dict):
                    message = first.get("message")
                    if isinstance(message, dict):
                        content = message.get("content")
                        if isinstance(content, str) and content.strip():
                            return content.strip()[:1000]

        if raw:
            return raw.strip()[:1000]
        return ""

    def _run_model_test_request(self, args: Dict[str, Any]) -> Dict[str, Any]:
        base_url = str(args.get("base_url", "")).strip().rstrip("/")
        api_mode = str(args.get("api_mode", "openai-completions")).strip()
        model_id = str(args.get("model_id", "")).strip()
        prompt = str(args.get("prompt", "")).strip()
        max_tokens = int(args.get("max_tokens", 64))

        headers: Dict[str, str] = {"Content-Type": "application/json"}
        custom_headers = args.get("headers", {})
        if isinstance(custom_headers, dict):
            for k, v in custom_headers.items():
                headers[str(k)] = str(v)

        api_key = str(args.get("api_key", "")).strip()
        if api_key:
            headers.setdefault("Authorization", f"Bearer {api_key}")
            headers.setdefault("api-key", api_key)

        modes = [api_mode]
        fallback_mode = (
            "openai-responses"
            if api_mode == "openai-completions"
            else "openai-completions"
        )
        if fallback_mode not in modes:
            modes.append(fallback_mode)

        base_candidates = [base_url]
        normalized_base = base_url.rstrip("/")
        if normalized_base.endswith("/v1"):
            alt_base = normalized_base[: -len("/v1")].rstrip("/")
        else:
            alt_base = f"{normalized_base}/v1"
        if alt_base and alt_base not in base_candidates:
            base_candidates.append(alt_base)

        def run_once(mode: str, base_variant: str) -> Dict[str, Any]:
            endpoint = (
                "/responses" if mode == "openai-responses" else "/chat/completions"
            )
            url = f"{base_variant}{endpoint}"

            if mode == "openai-responses":
                payload = {
                    "model": model_id,
                    "input": prompt,
                    "max_output_tokens": max_tokens,
                }
            else:
                payload = {
                    "model": model_id,
                    "messages": [{"role": "user", "content": prompt}],
                    "max_tokens": max_tokens,
                    "stream": False,
                }

            body = json.dumps(payload).encode("utf-8")
            request_obj = urllib.request.Request(
                url,
                data=body,
                headers=headers,
                method="POST",
            )

            started_at = time.perf_counter()
            try:
                with urllib.request.urlopen(request_obj, timeout=35) as resp:
                    raw = resp.read().decode("utf-8", errors="replace")
                    status = int(resp.getcode() or 0)

                latency_ms = int((time.perf_counter() - started_at) * 1000)
                parsed: Any = {}
                with contextlib.suppress(Exception):
                    parsed = json.loads(raw)

                preview = self._extract_test_preview(mode, parsed, raw)
                return {
                    "ok": 200 <= status < 300,
                    "status": status,
                    "latency_ms": latency_ms,
                    "preview": preview,
                    "error": "",
                    "url": url,
                }
            except urllib.error.HTTPError as exc:
                raw = exc.read().decode("utf-8", errors="replace")
                latency_ms = int((time.perf_counter() - started_at) * 1000)
                preview = raw.strip()[:1000]
                return {
                    "ok": False,
                    "status": int(exc.code or 0),
                    "latency_ms": latency_ms,
                    "preview": preview,
                    "error": str(exc),
                    "url": url,
                }
            except Exception as exc:  # noqa: BLE001
                latency_ms = int((time.perf_counter() - started_at) * 1000)
                return {
                    "ok": False,
                    "status": 0,
                    "latency_ms": latency_ms,
                    "preview": "",
                    "error": str(exc),
                    "url": url,
                }

        best_result: Optional[Dict[str, Any]] = None
        for base_variant in base_candidates:
            for mode in modes:
                current = run_once(mode, base_variant)
                if current.get("ok"):
                    return current

                if best_result is None:
                    best_result = current
                    continue

                if int(current.get("status", 0)) > int(best_result.get("status", 0)):
                    best_result = current

        return best_result or {
            "ok": False,
            "status": 0,
            "latency_ms": 0,
            "preview": "",
            "error": "model test failed",
            "url": base_url,
        }

    def _test_current_model(self) -> None:
        try:
            provider_id = self.provider_var.get().strip()
            base_url = self.base_url_var.get().strip()
            model_id = self.model_id_var.get().strip()
            api_mode = self.api_var.get().strip() or "openai-completions"
            api_key = self.api_key_var.get().strip()

            missing: List[str] = []
            if not provider_id:
                missing.append(self._t("label_provider_id"))
            if not base_url:
                missing.append(self._t("label_base_url"))
            if not model_id:
                missing.append(self._t("label_model_id"))
            if not api_key:
                missing.append(self._t("label_api_key"))

            if missing:
                messagebox.showerror(
                    self._t("title_error"),
                    self._t("msg_test_missing", fields=", ".join(missing)),
                )
                return

            prompt = self.test_prompt_text.get("1.0", tk.END).strip() or self._t(
                "default_test_prompt"
            )
            tokens_raw = self.test_max_tokens_var.get().strip() or "64"
            max_tokens = int(tokens_raw)
            if max_tokens <= 0:
                raise ValueError(self._t("msg_test_bad_tokens"))

            headers = dict(self._parse_headers_text())
            model_ref = f"{provider_id}/{model_id}"

            run_args = {
                "base_url": base_url,
                "api_mode": api_mode,
                "model_id": model_id,
                "prompt": prompt,
                "max_tokens": max_tokens,
                "api_key": api_key,
                "auth_header": self.auth_header_var.get(),
                "headers": headers,
            }

            def worker() -> Dict[str, Any]:
                return self._run_model_test_request(run_args)

            def on_done(result: Dict[str, Any]) -> None:
                self._log(f"$ model-test {model_ref}")
                self._log(f"POST {result.get('url', '-')}")
                self._emit_command_result(
                    {
                        "command": "",
                        "stdout": result.get("preview", ""),
                        "stderr": "" if result.get("ok") else result.get("error", ""),
                    }
                )

                status = int(result.get("status", 0))
                latency_ms = int(result.get("latency_ms", 0))
                preview = str(result.get("preview", "")).strip() or "-"
                error_text = str(result.get("error", "")).strip() or "-"

                if bool(result.get("ok")):
                    self._set_status(self._t("status_cmd_ok"), ok=True)
                    messagebox.showinfo(
                        self._t("title_test"),
                        self._t(
                            "msg_test_success",
                            model_ref=model_ref,
                            latency_ms=latency_ms,
                            preview=preview,
                        ),
                    )
                else:
                    self._set_status(
                        self._t("status_cmd_failed", code=status), ok=False
                    )
                    messagebox.showerror(
                        self._t("title_test_failed"),
                        self._t(
                            "msg_test_failed",
                            model_ref=model_ref,
                            status=status,
                            error=error_text,
                            preview=preview,
                        ),
                    )

            self._run_async(self._t("status_running_test"), worker, on_done)
        except Exception as exc:  # noqa: BLE001
            self._set_status(str(exc), ok=False)
            self._log(self._t("log_error", error=exc))
            messagebox.showerror(self._t("title_error"), str(exc))

    def _open_model_wizard(self) -> None:
        if self._busy:
            messagebox.showinfo(self._t("title_info"), self._t("msg_busy"))
            return

        dialog = tk.Toplevel(self.root)
        dialog.title(self._t("wizard_title"))
        dialog.transient(self.root)
        dialog.grab_set()
        dialog.geometry("760x520")

        provider_var = tk.StringVar(value=self.provider_var.get().strip())
        base_url_var = tk.StringVar(value=self.base_url_var.get().strip())
        api_key_var = tk.StringVar(value=self.api_key_var.get().strip())
        api_mode_var = tk.StringVar(
            value=self.api_var.get().strip() or "openai-completions"
        )

        model_id_var = tk.StringVar(value=self.model_id_var.get().strip())
        model_name_var = tk.StringVar(value=self.model_name_var.get().strip())
        inputs_var = tk.StringVar(value=self.inputs_var.get().strip() or "text")
        context_var = tk.StringVar(
            value=self.context_window_var.get().strip() or "200000"
        )
        tokens_var = tk.StringVar(value=self.max_tokens_var.get().strip() or "8192")
        reasoning_var = tk.BooleanVar(value=self.reasoning_var.get())

        auth_header_var = tk.BooleanVar(value=self.auth_header_var.get())
        set_primary_var = tk.BooleanVar(value=self.set_primary_var.get())
        restart_gateway_var = tk.BooleanVar(value=self.restart_gateway_var.get())
        probe_var = tk.BooleanVar(value=self.probe_after_write_var.get())
        fallback_var = tk.StringVar(value=self.fallbacks_var.get().strip())

        step_index = {"value": 0}
        step_frames: List[Any] = []

        dialog.columnconfigure(0, weight=1)
        dialog.rowconfigure(1, weight=1)

        step_title = ttk.Label(dialog, text="", padding=(12, 12, 12, 8))
        step_title.grid(row=0, column=0, sticky="w")

        body = ttk.Frame(dialog, padding=(12, 0, 12, 8))
        body.grid(row=1, column=0, sticky="nsew")
        body.columnconfigure(0, weight=1)
        body.rowconfigure(0, weight=1)

        step1 = ttk.Frame(body)
        step1.columnconfigure(1, weight=1)
        ttk.Label(step1, text=self._t("wizard_provider_hint")).grid(
            row=0, column=0, sticky="w", padx=(0, 8), pady=(0, 8)
        )
        ttk.Entry(step1, textvariable=provider_var).grid(
            row=0, column=1, sticky="ew", pady=(0, 8)
        )

        ttk.Label(step1, text=self._t("wizard_base_url_hint")).grid(
            row=1, column=0, sticky="w", padx=(0, 8), pady=(0, 8)
        )
        ttk.Entry(step1, textvariable=base_url_var).grid(
            row=1, column=1, sticky="ew", pady=(0, 8)
        )

        ttk.Label(step1, text=self._t("wizard_api_mode_hint")).grid(
            row=2, column=0, sticky="w", padx=(0, 8), pady=(0, 8)
        )
        ttk.Combobox(
            step1,
            textvariable=api_mode_var,
            values=["openai-completions", "openai-responses"],
            state="readonly",
        ).grid(row=2, column=1, sticky="ew", pady=(0, 8))

        ttk.Label(step1, text=self._t("wizard_api_key_hint")).grid(
            row=3, column=0, sticky="w", padx=(0, 8)
        )
        ttk.Entry(step1, textvariable=api_key_var, show="*").grid(
            row=3, column=1, sticky="ew"
        )

        step2 = ttk.Frame(body)
        step2.columnconfigure(1, weight=1)
        ttk.Label(step2, text=self._t("wizard_model_id_hint")).grid(
            row=0, column=0, sticky="w", padx=(0, 8), pady=(0, 8)
        )
        ttk.Entry(step2, textvariable=model_id_var).grid(
            row=0, column=1, sticky="ew", pady=(0, 8)
        )

        ttk.Label(step2, text=self._t("wizard_model_name_hint")).grid(
            row=1, column=0, sticky="w", padx=(0, 8), pady=(0, 8)
        )
        ttk.Entry(step2, textvariable=model_name_var).grid(
            row=1, column=1, sticky="ew", pady=(0, 8)
        )

        ttk.Label(step2, text=self._t("wizard_inputs_hint")).grid(
            row=2, column=0, sticky="w", padx=(0, 8), pady=(0, 8)
        )
        ttk.Entry(step2, textvariable=inputs_var).grid(
            row=2, column=1, sticky="ew", pady=(0, 8)
        )

        ttk.Label(step2, text=self._t("wizard_context_hint")).grid(
            row=3, column=0, sticky="w", padx=(0, 8), pady=(0, 8)
        )
        ttk.Entry(step2, textvariable=context_var).grid(
            row=3, column=1, sticky="ew", pady=(0, 8)
        )

        ttk.Label(step2, text=self._t("wizard_tokens_hint")).grid(
            row=4, column=0, sticky="w", padx=(0, 8), pady=(0, 8)
        )
        ttk.Entry(step2, textvariable=tokens_var).grid(
            row=4, column=1, sticky="ew", pady=(0, 8)
        )

        ttk.Checkbutton(
            step2, text=self._t("check_reasoning"), variable=reasoning_var
        ).grid(row=5, column=1, sticky="w")

        step3 = ttk.Frame(body)
        step3.columnconfigure(1, weight=1)
        ttk.Checkbutton(
            step3, text=self._t("check_auth_header"), variable=auth_header_var
        ).grid(row=0, column=0, columnspan=2, sticky="w", pady=(0, 8))
        ttk.Checkbutton(
            step3, text=self._t("check_set_primary"), variable=set_primary_var
        ).grid(row=1, column=0, columnspan=2, sticky="w", pady=(0, 8))
        ttk.Checkbutton(
            step3,
            text=self._t("check_restart_gateway"),
            variable=restart_gateway_var,
        ).grid(row=2, column=0, columnspan=2, sticky="w", pady=(0, 8))
        ttk.Checkbutton(
            step3, text=self._t("check_probe_after"), variable=probe_var
        ).grid(row=3, column=0, columnspan=2, sticky="w", pady=(0, 8))

        ttk.Label(step3, text=self._t("wizard_fallback_hint")).grid(
            row=4, column=0, sticky="w", padx=(0, 8), pady=(4, 8)
        )
        ttk.Entry(step3, textvariable=fallback_var).grid(
            row=4, column=1, sticky="ew", pady=(4, 8)
        )

        ttk.Label(step3, text=self._t("wizard_headers_hint")).grid(
            row=5, column=0, sticky="nw", padx=(0, 8)
        )
        headers_text = scrolledtext.ScrolledText(step3, height=7)
        headers_text.grid(row=5, column=1, sticky="nsew")
        headers_text.insert("1.0", self.headers_text.get("1.0", tk.END))
        step3.rowconfigure(5, weight=1)

        step_frames.extend([step1, step2, step3])

        for frame in step_frames:
            frame.grid(row=0, column=0, sticky="nsew")

        footer = ttk.Frame(dialog, padding=(12, 8, 12, 12))
        footer.grid(row=2, column=0, sticky="ew")
        footer.columnconfigure(0, weight=1)

        step_label = ttk.Label(footer, text="")
        step_label.grid(row=0, column=0, sticky="w")

        btn_cancel = ttk.Button(
            footer, text=self._t("wizard_cancel"), command=dialog.destroy
        )
        btn_cancel.grid(row=0, column=1, padx=(8, 0))
        btn_prev = ttk.Button(footer, text=self._t("wizard_prev"))
        btn_prev.grid(row=0, column=2, padx=(8, 0))
        btn_next = ttk.Button(footer, text=self._t("wizard_next"))
        btn_next.grid(row=0, column=3, padx=(8, 0))
        btn_finish = ttk.Button(footer, text=self._t("wizard_finish"))
        btn_finish.grid(row=0, column=4, padx=(8, 0))

        step_title_keys = ["wizard_s1_title", "wizard_s2_title", "wizard_s3_title"]

        def refresh_step() -> None:
            idx = step_index["value"]
            for i, frame in enumerate(step_frames):
                if i == idx:
                    frame.tkraise()

            step_title.configure(text=self._t(step_title_keys[idx]))
            step_label.configure(text=self._t("wizard_step", index=idx + 1))
            btn_prev.configure(state="normal" if idx > 0 else "disabled")
            btn_next.configure(state="normal" if idx < 2 else "disabled")
            btn_finish.configure(state="normal" if idx == 2 else "disabled")

        def go_prev() -> None:
            if step_index["value"] > 0:
                step_index["value"] -= 1
                refresh_step()

        def go_next() -> None:
            if step_index["value"] < 2:
                step_index["value"] += 1
                refresh_step()

        def finish() -> None:
            self.provider_var.set(provider_var.get().strip())
            self.base_url_var.set(base_url_var.get().strip())
            self.api_var.set(api_mode_var.get().strip() or "openai-completions")
            self.api_key_var.set(api_key_var.get().strip())
            self.model_id_var.set(model_id_var.get().strip())
            self.model_name_var.set(model_name_var.get().strip())
            self.inputs_var.set(inputs_var.get().strip() or "text")
            self.context_window_var.set(context_var.get().strip() or "200000")
            self.max_tokens_var.set(tokens_var.get().strip() or "8192")
            self.reasoning_var.set(reasoning_var.get())
            self.auth_header_var.set(auth_header_var.get())
            self.set_primary_var.set(set_primary_var.get())
            self.restart_gateway_var.set(restart_gateway_var.get())
            self.probe_after_write_var.set(probe_var.get())
            self.fallbacks_var.set(fallback_var.get().strip())

            self.headers_text.delete("1.0", tk.END)
            self.headers_text.insert("1.0", headers_text.get("1.0", tk.END))

            dialog.destroy()
            self._upsert_provider_model()

        btn_prev.configure(command=go_prev)
        btn_next.configure(command=go_next)
        btn_finish.configure(command=finish)

        refresh_step()
        dialog.focus_set()

    def _upsert_provider_model(self) -> None:
        try:
            provider_id = self.provider_var.get().strip()
            base_url = self.base_url_var.get().strip()
            api_key = self.api_key_var.get().strip()
            model_id = self.model_id_var.get().strip()
            model_name = self.model_name_var.get().strip() or model_id

            if not provider_id:
                raise ValueError(self._t("err_provider_required"))
            if not base_url:
                raise ValueError(self._t("err_base_url_required"))
            if not api_key:
                raise ValueError(self._t("err_api_key_required"))
            if not model_id:
                raise ValueError(self._t("err_model_id_required"))

            int(self.context_window_var.get().strip())
            int(self.max_tokens_var.get().strip())

            headers = self._parse_headers_text()

            fallback_items: List[str] = []
            fallback_text = self.fallbacks_var.get().strip()
            if fallback_text:
                fallback_items = [
                    x.strip() for x in fallback_text.split(",") if x.strip()
                ]

            run_args = {
                "config": self.config_path_var.get().strip(),
                "provider_id": provider_id,
                "base_url": base_url,
                "api": self.api_var.get().strip(),
                "api_key": api_key,
                "model_id": model_id,
                "model_name": model_name,
                "context_window": int(self.context_window_var.get().strip()),
                "max_tokens": int(self.max_tokens_var.get().strip()),
                "reasoning": "true" if self.reasoning_var.get() else "false",
                "input": self.inputs_var.get().strip() or "text",
                "header": [f"{key}={value}" for key, value in headers],
                "auth_header": self.auth_header_var.get(),
                "set_primary": self.set_primary_var.get(),
                "fallback": fallback_items,
                "restart_gateway": self.restart_gateway_var.get(),
                "probe": self.probe_after_write_var.get(),
                "dry_run": False,
            }

            def worker() -> Dict[str, Any]:
                return self._run_cli_module_command("quick-add", run_args)

            def on_done(result: Dict[str, Any]) -> None:
                self._emit_command_result(result)
                code = int(result.get("code", 1))
                if code == 0:
                    self.refresh_all()
                    self._set_status(self._t("status_cmd_ok"), ok=True)
                    messagebox.showinfo(self._t("title_success"), self._t("msg_saved"))
                else:
                    self._set_status(self._t("status_cmd_failed", code=code), ok=False)
                    messagebox.showerror(
                        self._t("title_failed"),
                        self._t("msg_cmd_failed", code=code),
                    )

            self._run_async(self._t("status_running_save"), worker, on_done)
        except Exception as exc:
            self._set_status(str(exc), ok=False)
            self._log(self._t("log_error", error=exc))
            messagebox.showerror(self._t("title_error"), str(exc))

    def _set_primary(self) -> None:
        primary_ref = self.primary_ref_var.get().strip()
        if not primary_ref:
            provider = self.provider_var.get().strip()
            model = self.model_id_var.get().strip()
            if provider and model:
                primary_ref = f"{provider}/{model}"

        if not primary_ref:
            messagebox.showerror(
                self._t("title_error"),
                self._t("msg_primary_required"),
            )
            return

        run_args = {
            "config": self.config_path_var.get().strip(),
            "model_ref": primary_ref,
            "restart_gateway": self.restart_gateway_var.get(),
            "probe": self.probe_after_write_var.get(),
            "dry_run": False,
        }

        def worker() -> Dict[str, Any]:
            return self._run_cli_module_command("set-primary", run_args)

        def on_done(result: Dict[str, Any]) -> None:
            self._emit_command_result(result)
            code = int(result.get("code", 1))
            if code == 0:
                self.refresh_all()
                self._set_status(self._t("status_cmd_ok"), ok=True)
                messagebox.showinfo(
                    self._t("title_success"),
                    self._t("msg_primary_set", primary_ref=primary_ref),
                )
            else:
                self._set_status(self._t("status_cmd_failed", code=code), ok=False)
                messagebox.showerror(
                    self._t("title_failed"),
                    self._t("msg_cmd_failed", code=code),
                )

        self._run_async(self._t("status_running_primary"), worker, on_done)

    def _probe_models(self) -> None:
        def worker() -> Dict[str, Any]:
            return self._run_subprocess(["openclaw", "models", "status", "--probe"])

        def on_done(result: Dict[str, Any]) -> None:
            self._emit_command_result(result)
            code = int(result.get("code", 1))
            if code == 0:
                self._set_status(self._t("status_cmd_ok"), ok=True)
                messagebox.showinfo(self._t("title_probe"), self._t("msg_probe_done"))
            else:
                self._set_status(self._t("status_cmd_failed", code=code), ok=False)
                messagebox.showerror(
                    self._t("title_probe_failed"),
                    self._t("msg_probe_failed", code=code),
                )

        self._run_async(self._t("status_running_probe"), worker, on_done)

    def _restart_gateway(self) -> None:
        def worker() -> List[Dict[str, Any]]:
            first = self._run_subprocess(["openclaw", "gateway", "restart"], 25.0)
            results = [first]
            if int(first.get("code", 1)) == 0:
                results.append(
                    self._run_subprocess(
                        ["openclaw", "gateway", "status", "--json"],
                        12.0,
                    )
                )
            return results

        def on_done(results: List[Dict[str, Any]]) -> None:
            for item in results:
                self._emit_command_result(item)

            code = int(results[0].get("code", 1)) if results else 1
            if code == 0:
                self._set_status(self._t("status_cmd_ok"), ok=True)
                messagebox.showinfo(
                    self._t("title_gateway"),
                    self._t("msg_gateway_done"),
                )
            else:
                self._set_status(self._t("status_cmd_failed", code=code), ok=False)
                messagebox.showerror(
                    self._t("title_gateway_failed"),
                    self._t("msg_gateway_failed", code=code),
                )

        self._run_async(self._t("status_running_gateway"), worker, on_done)


def launch_gui(config_path: pathlib.Path) -> int:
    if TK_IMPORT_ERROR is not None:
        print(f"Tkinter 不可用: {TK_IMPORT_ERROR}", file=sys.stderr)
        return 1

    cli_script = _resolve_cli_script_path()
    if not cli_script.exists():
        print(f"未找到所需 CLI 脚本: {cli_script}", file=sys.stderr)
        return 1

    root = tk.Tk()
    app = QuickConfigGUI(root, config_path=config_path, cli_script=cli_script)
    app._log("界面已启动")
    root.protocol("WM_DELETE_WINDOW", app._on_window_close)
    root.mainloop()
    return 0


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="OpenClaw 快速配置图形界面")
    parser.add_argument(
        "--config", default=str(DEFAULT_CONFIG_PATH), help="openclaw.json 路径"
    )
    return parser


def main() -> int:
    args = build_parser().parse_args()
    return launch_gui(pathlib.Path(args.config).expanduser())


if __name__ == "__main__":
    sys.exit(main())