diff --git a/electron/welcome/lang/en.ts b/electron/welcome/lang/en.ts
index 4e11c32d2f16787a2e5d024bef39f1e486abc76a..d79422a9f8b20e43ec56bb93291053f910356d2d 100644
--- a/electron/welcome/lang/en.ts
+++ b/electron/welcome/lang/en.ts
@@ -8,6 +8,7 @@ export default {
     pleaseInput: 'Please Input',
     validUrl: 'Please enter a valid URL',
     validationFailure: 'Validation failure',
+    connectionFailed: 'Connection failed',
   },
   localDeploy: {
     model: 'Large model',
@@ -24,6 +25,14 @@ export default {
     stopInstall: 'Stop installation',
     complete: 'Complete',
     retry: 'Retry',
+    validationFailed: 'Validation Failed',
+    authError: 'Authentication failed, please check if the API Key is correct',
+    functionCallNotSupported:
+      'Function Call not supported, please use a model that supports this feature',
+    connectionError: 'Connection failed, please check if the URL is correct',
+    modelError: 'Model validation failed',
+    llmValidationFailed: 'LLM validation failed',
+    embeddingValidationFailed: 'Embedding model validation failed',
   },
   onlineService: {
     serviceUrl: 'Backend Service Links',
diff --git a/electron/welcome/lang/index.ts b/electron/welcome/lang/index.ts
index 736df67cb4b0bec3e07de197972c362b5d6c6eea..2c1acbd4894b86151d3a0ca5b4c36a025e6e7a90 100644
--- a/electron/welcome/lang/index.ts
+++ b/electron/welcome/lang/index.ts
@@ -3,7 +3,130 @@ import { createI18n } from 'vue-i18n';
 import zh from './zh';
 import en from './en';
 
-const locale = 'zh';
+/**
+ * 开发模式日志输出
+ * 只在开发环境下输出日志
+ */
+function devLog(...args: any[]) {
+  if (import.meta.env.DEV || process.env.NODE_ENV === 'development') {
+    console.log(...args);
+  }
+}
+
+/**
+ * 开发模式警告输出
+ * 只在开发环境下输出警告
+ */
+function devWarn(...args: any[]) {
+  if (import.meta.env.DEV || process.env.NODE_ENV === 'development') {
+    console.warn(...args);
+  }
+}
+
+/**
+ * 检测系统语言
+ * 支持多种操作系统的语言检测
+ * @returns {'zh' | 'en'} 语言代码 'zh' 或 'en'
+ */
+function detectSystemLanguage(): 'zh' | 'en' {
+  let systemLanguage: 'zh' | 'en' = 'zh'; // 默认中文
+
+  try {
+    // 优先级1: 检查 Electron 环境中的系统信息
+    if (typeof window !== 'undefined' && window.eulercopilotWelcome?.system) {
+      const { platform, env } = window.eulercopilotWelcome.system;
+
+      devLog(`检测到系统平台: ${platform}`);
+
+      // 根据不同操作系统检测语言
+      if (platform === 'win32') {
+        // Windows 系统语言检测
+        const winLang = env.LANG || env.LC_ALL || env.LANGUAGE || '';
+        if (
+          winLang.toLowerCase().includes('zh') ||
+          winLang.toLowerCase().includes('chinese') ||
+          winLang.toLowerCase().includes('chs') ||
+          winLang.toLowerCase().includes('cn')
+        ) {
+          systemLanguage = 'zh';
+        } else if (winLang && !winLang.toLowerCase().includes('zh')) {
+          systemLanguage = 'en';
+        }
+      } else if (platform === 'darwin') {
+        // macOS 系统语言检测
+        const macLang =
+          env.LANG || env.LC_ALL || env.LC_MESSAGES || env.LANGUAGE || '';
+        if (
+          macLang.toLowerCase().includes('zh') ||
+          macLang.toLowerCase().includes('chinese') ||
+          macLang.toLowerCase().includes('cn')
+        ) {
+          systemLanguage = 'zh';
+        } else if (macLang && !macLang.toLowerCase().includes('zh')) {
+          systemLanguage = 'en';
+        }
+      } else if (platform === 'linux') {
+        // Linux 系统语言检测
+        const linuxLang =
+          env.LANG || env.LC_ALL || env.LC_MESSAGES || env.LANGUAGE || '';
+        if (
+          linuxLang.toLowerCase().includes('zh') ||
+          linuxLang.toLowerCase().includes('chinese') ||
+          linuxLang.toLowerCase().includes('cn')
+        ) {
+          systemLanguage = 'zh';
+        } else if (linuxLang && !linuxLang.toLowerCase().includes('zh')) {
+          systemLanguage = 'en';
+        }
+      }
+
+      devLog(`根据环境变量检测到语言: ${systemLanguage}`);
+      return systemLanguage; // 如果 Electron 环境可用，直接返回结果
+    }
+
+    // 优先级2: 浏览器语言检测 (作为后备方案)
+    if (typeof navigator !== 'undefined' && navigator.language) {
+      const browserLang = navigator.language.toLowerCase();
+
+      devLog(`浏览器语言: ${browserLang}`);
+
+      // 检测是否为中文相关语言
+      if (
+        browserLang.startsWith('zh') ||
+        browserLang.includes('china') ||
+        browserLang.includes('chinese') ||
+        browserLang === 'zh-cn' ||
+        browserLang === 'zh-tw' ||
+        browserLang === 'zh-hk'
+      ) {
+        systemLanguage = 'zh';
+      }
+      // 检测是否为英文相关语言
+      else if (
+        browserLang.startsWith('en') ||
+        browserLang.includes('english') ||
+        browserLang.includes('us') ||
+        browserLang.includes('gb')
+      ) {
+        systemLanguage = 'en';
+      }
+      // 其他语言默认使用英文
+      else {
+        systemLanguage = 'en';
+      }
+    }
+
+    devLog(`最终检测到的系统语言: ${systemLanguage}`);
+  } catch (error) {
+    devWarn('检测系统语言失败，使用默认中文:', error);
+    systemLanguage = 'zh';
+  }
+
+  return systemLanguage;
+}
+
+// 检测系统语言，默认中文
+const locale = detectSystemLanguage();
 
 const i18n_welcome = createI18n({
   legacy: false, // 设置为 false，启用 composition API 模式
@@ -13,4 +136,41 @@ const i18n_welcome = createI18n({
     en,
   },
 });
-export default i18n_welcome;
\ No newline at end of file
+
+/**
+ * 在 Electron 环境准备好后重新检测语言
+ * 这个函数会在应用初始化后调用，确保能获取到正确的系统语言
+ */
+export function redetectLanguageOnReady() {
+  // 等待一小段时间让 Electron preload 脚本完成初始化
+  setTimeout(() => {
+    const newLocale = detectSystemLanguage();
+    if (newLocale !== i18n_welcome.global.locale.value) {
+      devLog(
+        `重新检测到语言变化，从 ${i18n_welcome.global.locale.value} 切换到 ${newLocale}`,
+      );
+      i18n_welcome.global.locale.value = newLocale;
+    }
+  }, 100);
+}
+
+/**
+ * 切换语言
+ * @param {string} newLocale 新的语言代码 'zh' 或 'en'
+ */
+export function changeLanguage(newLocale: 'zh' | 'en') {
+  if (i18n_welcome.global.locale) {
+    i18n_welcome.global.locale.value = newLocale;
+    devLog(`语言已切换到: ${newLocale}`);
+  }
+}
+
+/**
+ * 获取当前语言
+ * @returns {'zh' | 'en'} 当前语言代码
+ */
+export function getCurrentLanguage(): 'zh' | 'en' {
+  return i18n_welcome.global.locale.value as 'zh' | 'en';
+}
+
+export default i18n_welcome;
diff --git a/electron/welcome/lang/zh.ts b/electron/welcome/lang/zh.ts
index 8ee6c69c8f2cf46776cb6cce87b76bda7df8de5a..6bf89e1af890edfd6c2e0a7295c9351b9b937144 100644
--- a/electron/welcome/lang/zh.ts
+++ b/electron/welcome/lang/zh.ts
@@ -8,6 +8,7 @@ export default {
     pleaseInput: '请输入',
     validUrl: '请输入有效的 URL',
     validationFailure: '检验失败',
+    connectionFailed: '连接失败',
   },
   localDeploy: {
     model: '大模型',
@@ -24,6 +25,13 @@ export default {
     stopInstall: '停止安装',
     complete: '完成',
     retry: '重试',
+    validationFailed: '校验失败',
+    authError: '鉴权失败，请检查 API Key 是否正确',
+    functionCallNotSupported: '不支持 Function Call，请使用支持此功能的模型',
+    connectionError: '连接失败，请检查 URL 是否正确',
+    modelError: '模型验证失败',
+    llmValidationFailed: '大模型校验失败',
+    embeddingValidationFailed: 'Embedding 模型校验失败',
   },
   onlineService: {
     serviceUrl: '后端服务链接',
diff --git a/electron/welcome/localDeploy.vue b/electron/welcome/localDeploy.vue
index e9fde6021c7db08d489c928e05373ea5ded71cb5..2a55e26edb0981c34cd1259e34ce379bbd3ff123 100644
--- a/electron/welcome/localDeploy.vue
+++ b/electron/welcome/localDeploy.vue
@@ -20,7 +20,28 @@
     >
       <div class="model-title">
         {{ $t('localDeploy.model') }}
-        <img :src="successIcon" alt="success" width="16" height="16" />
+        <img
+          v-if="llmValidationStatus === 'validating'"
+          :src="loadingIcon"
+          alt="validating"
+          width="16"
+          height="16"
+          class="loading-icon"
+        />
+        <img
+          v-else-if="llmValidationStatus === 'success'"
+          :src="successIcon"
+          alt="success"
+          width="16"
+          height="16"
+        />
+        <img
+          v-else-if="llmValidationStatus === 'error'"
+          :src="errorIcon"
+          alt="error"
+          width="16"
+          height="16"
+        />
       </div>
       <el-form-item
         :label="$t('localDeploy.url')"
@@ -30,6 +51,11 @@
         <el-input
           :placeholder="$t('welcome.pleaseInput')"
           v-model="ruleForm.url"
+          @focus="inputFocusStates.llmUrl = true"
+          @blur="
+            inputFocusStates.llmUrl = false;
+            autoValidateModels();
+          "
         />
       </el-form-item>
       <el-form-item
@@ -40,6 +66,11 @@
         <el-input
           :placeholder="$t('welcome.pleaseInput')"
           v-model="ruleForm.modelName"
+          @focus="inputFocusStates.llmModelName = true"
+          @blur="
+            inputFocusStates.llmModelName = false;
+            autoValidateModels();
+          "
         />
       </el-form-item>
       <el-form-item
@@ -50,6 +81,11 @@
         <el-input
           :placeholder="$t('welcome.pleaseInput')"
           v-model="ruleForm.apiKey"
+          @focus="inputFocusStates.llmApiKey = true"
+          @blur="
+            inputFocusStates.llmApiKey = false;
+            autoValidateModels();
+          "
         />
       </el-form-item>
     </el-form>
@@ -64,7 +100,28 @@
     >
       <div class="model-title">
         {{ $t('localDeploy.embeddingModel') }}
-        <img :src="successIcon" alt="success" width="16" height="16" />
+        <img
+          v-if="embeddingValidationStatus === 'validating'"
+          :src="loadingIcon"
+          alt="validating"
+          width="16"
+          height="16"
+          class="loading-icon"
+        />
+        <img
+          v-else-if="embeddingValidationStatus === 'success'"
+          :src="successIcon"
+          alt="success"
+          width="16"
+          height="16"
+        />
+        <img
+          v-else-if="embeddingValidationStatus === 'error'"
+          :src="errorIcon"
+          alt="error"
+          width="16"
+          height="16"
+        />
       </div>
       <el-form-item
         :label="$t('localDeploy.url')"
@@ -74,6 +131,11 @@
         <el-input
           :placeholder="$t('welcome.pleaseInput')"
           v-model="embeddingRuleForm.url"
+          @focus="inputFocusStates.embeddingUrl = true"
+          @blur="
+            inputFocusStates.embeddingUrl = false;
+            autoValidateModels();
+          "
         >
           <template #suffix>
             <el-tooltip
@@ -97,6 +159,11 @@
         <el-input
           :placeholder="$t('welcome.pleaseInput')"
           v-model="embeddingRuleForm.modelName"
+          @focus="inputFocusStates.embeddingModelName = true"
+          @blur="
+            inputFocusStates.embeddingModelName = false;
+            autoValidateModels();
+          "
         />
       </el-form-item>
       <el-form-item
@@ -107,6 +174,11 @@
         <el-input
           :placeholder="$t('welcome.pleaseInput')"
           v-model="embeddingRuleForm.apiKey"
+          @focus="inputFocusStates.embeddingApiKey = true"
+          @blur="
+            inputFocusStates.embeddingApiKey = false;
+            autoValidateModels();
+          "
         />
       </el-form-item>
     </el-form>
@@ -127,8 +199,11 @@
 <script lang="ts" setup>
 import { reactive, ref, watch } from 'vue';
 import type { FormInstance, FormRules } from 'element-plus';
+import { ElMessageBox } from 'element-plus';
 import copyIcon from './assets/svgs/copy_icon.svg';
 import successIcon from './assets/svgs/success.svg';
+import errorIcon from './assets/svgs/error.svg';
+import loadingIcon from './assets/svgs/upload-loading.svg';
 import TimeLine from './timeLine.vue';
 import leftArrowIcon from './assets/svgs/left_arrow.svg';
 import i18n from './lang/index';
@@ -164,6 +239,24 @@ const embeddingRuleFormRef = ref<FormInstance>();
 const isConfirmDisabled = ref(true);
 const isTimeLine = ref(false);
 
+// 输入框焦点状态跟踪
+const inputFocusStates = ref({
+  llmUrl: false,
+  llmModelName: false,
+  llmApiKey: false,
+  embeddingUrl: false,
+  embeddingModelName: false,
+  embeddingApiKey: false,
+});
+
+// 模型验证状态
+const llmValidationStatus = ref<'none' | 'validating' | 'success' | 'error'>(
+  'none',
+);
+const embeddingValidationStatus = ref<
+  'none' | 'validating' | 'success' | 'error'
+>('none');
+
 const rules = reactive<FormRules<RuleForm>>({
   url: [
     {
@@ -198,50 +291,310 @@ const rules = reactive<FormRules<RuleForm>>({
   ],
 });
 
+// 检查是否所有字段都填写完整
+const isAllFieldsFilled = () => {
+  return (
+    ruleForm.url &&
+    ruleForm.modelName &&
+    ruleForm.apiKey &&
+    embeddingRuleForm.url &&
+    embeddingRuleForm.modelName &&
+    embeddingRuleForm.apiKey
+  );
+};
+
+// 检查是否有输入框处于焦点状态
+const hasInputFocus = () => {
+  return Object.values(inputFocusStates.value).some((state) => state);
+};
+
+// 自动验证模型
+const autoValidateModels = async () => {
+  if (!isAllFieldsFilled() || hasInputFocus()) {
+    return;
+  }
+
+  // 重置验证状态
+  llmValidationStatus.value = 'validating';
+  embeddingValidationStatus.value = 'validating';
+
+  try {
+    // 校验 LLM
+    const llmResult = await validateOpenAIModel(
+      ruleForm.url,
+      ruleForm.apiKey,
+      ruleForm.modelName,
+      true,
+    );
+
+    if (llmResult.success) {
+      llmValidationStatus.value = 'success';
+    } else {
+      llmValidationStatus.value = 'error';
+      showValidationError('llm', llmResult.type || 'unknown');
+    }
+
+    // 校验 Embedding 模型
+    const embeddingResult = await validateOpenAIModel(
+      embeddingRuleForm.url,
+      embeddingRuleForm.apiKey,
+      embeddingRuleForm.modelName,
+      false,
+    );
+
+    if (embeddingResult.success) {
+      embeddingValidationStatus.value = 'success';
+    } else {
+      embeddingValidationStatus.value = 'error';
+      showValidationError('embedding', embeddingResult.type || 'unknown');
+    }
+  } catch (error) {
+    console.error('Model validation error:', error);
+    llmValidationStatus.value = 'error';
+    embeddingValidationStatus.value = 'error';
+  }
+};
+
 watch(
   [() => ruleForm, () => embeddingRuleForm],
-  ([newRuleForm, newEmbeddingRuleForm]) => {
-    // 检查所有必填字段是否都有值
-    const isRuleFormValid =
-      newRuleForm.url && newRuleForm.modelName && newRuleForm.apiKey;
-    const isEmbeddingRuleFormValid =
-      newEmbeddingRuleForm.url &&
-      newEmbeddingRuleForm.modelName &&
-      newEmbeddingRuleForm.apiKey;
-
-    // 如果两个表单都有效，则启用按钮
-    isConfirmDisabled.value = !(isRuleFormValid && isEmbeddingRuleFormValid);
+  () => {
+    // 当表单数据变化时，重置验证状态
+    llmValidationStatus.value = 'none';
+    embeddingValidationStatus.value = 'none';
+
+    // 延迟执行验证，避免在用户还在输入时触发
+    setTimeout(() => {
+      autoValidateModels();
+    }, 500);
   },
-  { immediate: true, deep: true }, // 立即执行一次初始检查
+  { immediate: true, deep: true },
+);
+
+// 监听验证状态变化，更新提交按钮状态
+watch(
+  [llmValidationStatus, embeddingValidationStatus],
+  ([llmStatus, embeddingStatus]) => {
+    // 只有当两个模型都验证成功时才启用提交按钮
+    isConfirmDisabled.value = !(
+      llmStatus === 'success' && embeddingStatus === 'success'
+    );
+  },
+  { immediate: true },
 );
 
 const copyText = (ruleForm: RuleForm) => {
   embeddingRuleForm.url = ruleForm.url;
   embeddingRuleForm.apiKey = ruleForm.apiKey;
 };
-const validateForm = async () => {
-  const [ruleFormValid] = await new Promise<[boolean, any]>((resolve) => {
-    ruleFormRef.value?.validate((valid, fields) => resolve([valid, fields]));
-  });
 
-  const [embeddingRuleFormValid] = await new Promise<[boolean, any]>(
-    (resolve) => {
-      embeddingRuleFormRef.value?.validate((valid, fields) =>
-        resolve([valid, fields]),
+// OpenAI API 校验函数
+const validateOpenAIModel = async (
+  url: string,
+  apiKey: string,
+  modelName: string,
+  isLLM: boolean = true,
+) => {
+  try {
+    // 格式化 URL
+    const baseURL = url.replace(/\/+$/, '');
+
+    // 首先尝试检查模型列表（如果支持的话）
+    let modelExists = true; // 默认假设模型存在，除非确认不存在
+
+    try {
+      const apiURL = baseURL.includes('/v1')
+        ? `${baseURL}/models`
+        : `${baseURL}/v1/models`;
+
+      const modelsResponse = await fetch(apiURL, {
+        method: 'GET',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+      });
+
+      if (modelsResponse.ok) {
+        const modelsData = await modelsResponse.json();
+        const availableModels = modelsData.data || [];
+
+        // 如果成功获取到模型列表，则检查模型是否存在
+        modelExists = availableModels.some(
+          (model: any) => model.id === modelName,
+        );
+
+        if (!modelExists) {
+          throw new Error('model_not_found');
+        }
+      } else if (modelsResponse.status === 401) {
+        throw new Error('auth');
+      }
+      // 如果是其他错误（如404），可能是不支持models接口，继续后续验证
+    } catch (modelsError: any) {
+      // 如果是认证错误，直接抛出
+      if (modelsError.message === 'auth') {
+        throw modelsError;
+      }
+      if (modelsError.message === 'model_not_found') {
+        throw modelsError;
+      }
+      // 其他错误（如不支持models接口）则继续进行实际调用测试
+      console.warn(
+        'Models API not supported or failed, proceeding with direct testing',
       );
-    },
-  );
+    }
+
+    if (isLLM) {
+      const chatURL = baseURL.includes('/v1')
+        ? `${baseURL}/chat/completions`
+        : `${baseURL}/v1/chat/completions`;
+
+      // 首先测试基本的聊天功能
+      const basicChatTest = {
+        model: modelName,
+        messages: [{ role: 'user', content: 'Hello' }],
+        max_tokens: 10,
+      };
+
+      const basicResponse = await fetch(chatURL, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(basicChatTest),
+      });
+
+      if (!basicResponse.ok) {
+        if (basicResponse.status === 401) {
+          throw new Error('auth');
+        }
+        throw new Error('connection');
+      }
+
+      // 然后测试 function call 支持
+      const testFunctionCall = {
+        model: modelName,
+        messages: [{ role: 'user', content: 'Test function call support' }],
+        functions: [
+          {
+            name: 'test_function',
+            description: 'A test function',
+            parameters: {
+              type: 'object',
+              properties: {
+                test: { type: 'string', description: 'Test parameter' },
+              },
+              required: ['test'],
+            },
+          },
+        ],
+        max_tokens: 10,
+      };
+
+      const functionResponse = await fetch(chatURL, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(testFunctionCall),
+      });
+
+      if (!functionResponse.ok) {
+        if (functionResponse.status === 400) {
+          // 检查错误信息是否表明不支持 function call
+          const errorData = await functionResponse.json().catch(() => null);
+          if (
+            errorData?.error?.message?.toLowerCase().includes('function') ||
+            errorData?.error?.message?.toLowerCase().includes('tool')
+          ) {
+            throw new Error('function_call_not_supported');
+          }
+        }
+        throw new Error('function_call_test_failed');
+      }
+    } else {
+      // 对于 embedding 模型，测试 embeddings 接口
+      const embeddingURL = baseURL.includes('/v1')
+        ? `${baseURL}/embeddings`
+        : `${baseURL}/v1/embeddings`;
 
-  if (!ruleFormValid || !embeddingRuleFormValid) {
-    return false;
+      const embeddingTest = {
+        model: modelName,
+        input: 'Test embedding',
+      };
+
+      const embeddingResponse = await fetch(embeddingURL, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(embeddingTest),
+      });
+
+      if (!embeddingResponse.ok) {
+        if (embeddingResponse.status === 401) {
+          throw new Error('auth');
+        }
+        throw new Error('connection');
+      }
+    }
+
+    return { success: true };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message || 'unknown',
+      type: error.message,
+    };
+  }
+};
+
+// 显示错误消息
+const showValidationError = (modelType: string, errorType: string) => {
+  let message = '';
+  const modelLabel =
+    modelType === 'llm'
+      ? i18n.global.t('localDeploy.model')
+      : i18n.global.t('localDeploy.embeddingModel');
+  const modelName =
+    modelType === 'llm' ? ruleForm.modelName : embeddingRuleForm.modelName;
+
+  switch (errorType) {
+    case 'auth':
+      message = `${modelLabel}: ${i18n.global.t('localDeploy.authError')}`;
+      break;
+    case 'function_call_not_supported':
+      message = `${modelLabel}: ${i18n.global.t('localDeploy.functionCallNotSupported')}`;
+      break;
+    case 'connection':
+    case 'function_call_test_failed':
+      message = `${modelLabel}: ${i18n.global.t('localDeploy.connectionError')}`;
+      break;
+    case 'model_not_found':
+      message = `${modelLabel}: 模型 "${modelName}" 不存在`;
+      break;
+    default:
+      message = `${modelLabel}: ${i18n.global.t('localDeploy.modelError')}`;
   }
-  return true;
+
+  ElMessageBox.alert(message, i18n.global.t('localDeploy.validationFailed'), {
+    confirmButtonText: i18n.global.t('welcome.confirm'),
+    type: 'error',
+  });
 };
 
 const handleConfirm = async () => {
   if (!ruleFormRef.value || !embeddingRuleFormRef.value) return;
-  const isValid = await validateForm();
-  if (!isValid) {
+
+  // 由于按钮只有在验证成功时才会启用，所以这里不需要再次验证
+  // 但为了安全起见，还是检查一下验证状态
+  if (
+    llmValidationStatus.value !== 'success' ||
+    embeddingValidationStatus.value !== 'success'
+  ) {
     return;
   }
 
@@ -320,7 +673,20 @@ const handleBack = () => {
   .el-input__icon {
     cursor: pointer;
   }
+  .loading-icon {
+    animation: rotate 1s linear infinite;
+  }
 }
+
+@keyframes rotate {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+
 .submit-btn {
   width: 100vw;
   display: flex;
diff --git a/electron/welcome/main.ts b/electron/welcome/main.ts
index 79899ab338594979ae5c436844dce24d9db13e91..fada465af83715504cbec262dfb14c0ad7100f3f 100644
--- a/electron/welcome/main.ts
+++ b/electron/welcome/main.ts
@@ -4,11 +4,24 @@ import { createApp } from 'vue';
 import WelcomeComponent from './index.vue';
 import ElementPlus from 'element-plus';
 import 'element-plus/dist/index.css';
-import i18n_welcome from './lang';
+import i18n_welcome, { redetectLanguageOnReady } from './lang';
+
+/**
+ * 开发模式日志输出
+ * 只在开发环境下输出日志
+ */
+function devLog(...args: any[]) {
+  if (import.meta.env.DEV || process.env.NODE_ENV === 'development') {
+    console.log(...args);
+  }
+}
 
 // 创建 Vue 应用并挂载
 const app: App = createApp(WelcomeComponent);
 app.use(ElementPlus).use(i18n_welcome);
 app.mount('#app');
 
-console.log('Welcome Vue app initialized');
+// 在应用挂载后重新检测语言
+redetectLanguageOnReady();
+
+devLog('Welcome Vue app initialized');
diff --git a/electron/welcome/onlineService.vue b/electron/welcome/onlineService.vue
index 31d1957da05941f7280a5d6446afd96e69bb434c..dbc838e84341746420973f70e685b5b8e8c51394 100644
--- a/electron/welcome/onlineService.vue
+++ b/electron/welcome/onlineService.vue
@@ -5,7 +5,9 @@
       <span class="back-btn-text">{{ $t('welcome.back') }}</span>
     </div>
     <span class="divider"></span>
-    <div class="welcome-detail-title-text">{{ $t('welcome.localDeploy') }}</div>
+    <div class="welcome-detail-title-text">
+      {{ $t('welcome.onlineService') }}
+    </div>
   </div>
   <el-form
     ref="ruleFormRef"
@@ -43,6 +45,7 @@
 <script lang="ts" setup>
 import { reactive, ref, onMounted } from 'vue';
 import type { FormInstance, FormRules } from 'element-plus';
+import { ElMessageBox } from 'element-plus';
 import leftArrowIcon from './assets/svgs/left_arrow.svg';
 import i18n from './lang/index';
 
@@ -120,15 +123,61 @@ onMounted(() => {
 
 const handleConfirm = async (formEl: FormInstance | undefined) => {
   if (!formEl) return;
-  await formEl.validate((valid, fields) => {
-    if (!valid) {
-      console.error('表单验证失败:', fields);
+
+  // 先进行表单验证
+  const isFormValid = await new Promise<boolean>((resolve) => {
+    formEl.validate((valid, fields) => {
+      if (!valid) {
+        console.error('表单验证失败:', fields);
+        resolve(false);
+        return;
+      }
+      resolve(true);
+    });
+  });
+
+  if (!isFormValid) return;
+
+  // 验证服务器连接
+  if (window.eulercopilotWelcome?.config) {
+    try {
+      const { isValid, error } =
+        await window.eulercopilotWelcome.config.validateServer(ruleForm.url);
+
+      if (!isValid) {
+        // 弹窗提醒用户连接失败
+        await ElMessageBox.alert(
+          error || i18n.global.t('welcome.validationFailure'),
+          i18n.global.t('welcome.connectionFailed'),
+          {
+            confirmButtonText: i18n.global.t('welcome.confirm'),
+            type: 'error',
+          },
+        );
+        return;
+      }
+
+      // 验证成功，设置代理 URL
+      await window.eulercopilotWelcome.config.setProxyUrl(ruleForm.url);
+    } catch (error) {
+      // 网络错误或其他异常
+      console.error('服务器验证失败:', error);
+      await ElMessageBox.alert(
+        i18n.global.t('welcome.validationFailure'),
+        i18n.global.t('welcome.connectionFailed'),
+        {
+          confirmButtonText: i18n.global.t('welcome.confirm'),
+          type: 'error',
+        },
+      );
       return;
     }
-    if (window.eulercopilotWelcome?.config) {
-      window.eulercopilotWelcome.config.setProxyUrl(ruleForm.url);
-    }
-  });
+  }
+
+  // 完成欢迎页面流程
+  if (window.eulercopilotWelcome?.welcome) {
+    await window.eulercopilotWelcome.welcome.complete();
+  }
 };
 
 const handleBack = () => {
diff --git a/electron/welcome/timeLine.vue b/electron/welcome/timeLine.vue
index 89d477c0f888d33b57dc2a0efd0ec618d0f3a3d9..8f8626fbb65dfc4f75850b612f3c44b5e19236e7 100644
--- a/electron/welcome/timeLine.vue
+++ b/electron/welcome/timeLine.vue
@@ -177,10 +177,17 @@ const updateActivitiesStatus = (status: any) => {
     } else if (currentStep === 'failed' || currentStep === 'stopped') {
       // 失败或停止状态
       activities.value.forEach((act) => {
-        if (act.type !== 'success') {
+        if (act.type === 'running') {
           act.type = 'failed';
         }
       });
+    } else if (currentStep === 'idle') {
+      // 空闲状态
+      activities.value.forEach((act) => {
+        if (act.type !== 'success') {
+          act.type = 'default';
+        }
+      });
     } else {
       // 未知步骤
       console.warn(`未知的部署步骤: ${currentStep}`);