@lobehub/lobehub 2.0.0-next.203 → 2.0.0-next.204

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 2.0.0-next.204](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.203...v2.0.0-next.204)
+
+<sup>Released on **2026-01-04**</sup>
+
+#### ✨ Features
+
+- **misc**: Add new provider Xiaomi MiMo.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **misc**: Add new provider Xiaomi MiMo, closes [#10834](https://github.com/lobehub/lobe-chat/issues/10834) ([62f7858](https://github.com/lobehub/lobe-chat/commit/62f7858))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.203](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.202...v2.0.0-next.203)
 
 <sup>Released on **2026-01-04**</sup>

package/apps/desktop/src/main/controllers/SystemCtr.ts

@@ -39,7 +39,6 @@ export default class SystemController extends ControllerModule {
       isMac: platform === 'darwin',
       isWindows: platform === 'win32',
       platform: platform as 'darwin' | 'win32' | 'linux',
-      systemAppearance: nativeTheme.shouldUseDarkColors ? 'dark' : 'light',
       userPath: {
         // User Paths (ensure keys match UserPathData / DesktopAppState interface)
         desktop: app.getPath('desktop'),
@@ -265,11 +264,6 @@ export default class SystemController extends ControllerModule {
 
     logger.info('Initializing system theme listener');
 
-    // Get initial system theme
-    const initialDarkMode = nativeTheme.shouldUseDarkColors;
-    const initialSystemTheme: ThemeMode = initialDarkMode ? 'dark' : 'light';
-    logger.info(`Initial system theme: ${initialSystemTheme}`);
-
     // Listen for system theme changes
     nativeTheme.on('updated', () => {
       const isDarkMode = nativeTheme.shouldUseDarkColors;

package/apps/desktop/src/main/controllers/__tests__/SystemCtr.test.ts

@@ -72,6 +72,7 @@ vi.mock('electron', () => ({
   nativeTheme: {
     on: vi.fn(),
     shouldUseDarkColors: false,
+    themeSource: 'system',
   },
   shell: {
     openExternal: vi.fn().mockResolvedValue(undefined),
@@ -138,7 +139,6 @@ describe('SystemController', () => {
       expect(result).toMatchObject({
         arch: expect.any(String),
         platform: expect.any(String),
-        systemAppearance: 'light',
         userPath: {
           desktop: '/mock/path/desktop',
           documents: '/mock/path/documents',
@@ -151,18 +151,6 @@ describe('SystemController', () => {
         },
       });
     });
-
-    it('should return dark appearance when nativeTheme is dark', async () => {
-      const { nativeTheme } = await import('electron');
-      Object.defineProperty(nativeTheme, 'shouldUseDarkColors', { value: true });
-
-      const result = await invokeIpc('system.getAppState');
-
-      expect(result.systemAppearance).toBe('dark');
-
-      // Reset
-      Object.defineProperty(nativeTheme, 'shouldUseDarkColors', { value: false });
-    });
   });
 
   describe('accessibility', () => {

package/apps/desktop/src/main/core/App.ts

@@ -6,7 +6,7 @@ import {
   RouteVariants,
 } from '@lobechat/desktop-bridge';
 import { ElectronIPCEventHandler, ElectronIPCServer } from '@lobechat/electron-server-ipc';
-import { app, protocol, session } from 'electron';
+import { app, nativeTheme, protocol, session } from 'electron';
 import installExtension, { REACT_DEVELOPER_TOOLS } from 'electron-devtools-installer';
 import { macOS, windows } from 'electron-is';
 import { pathExistsSync } from 'fs-extra';
@@ -154,9 +154,27 @@ export class App {
     // 统一处理 before-quit 事件
     app.on('before-quit', this.handleBeforeQuit);
 
+    // Initialize theme mode from store
+    this.initializeThemeMode();
+
     logger.info('App initialization completed');
   }
 
+  /**
+   * Initialize nativeTheme.themeSource from stored themeMode preference
+   * This allows nativeTheme.shouldUseDarkColors to be used consistently everywhere
+   */
+  private initializeThemeMode() {
+    const themeMode = this.storeManager.get('themeMode');
+
+    if (themeMode) {
+      nativeTheme.themeSource = themeMode === 'auto' ? 'system' : themeMode;
+      logger.debug(
+        `Theme mode initialized to: ${themeMode} (themeSource: ${nativeTheme.themeSource})`,
+      );
+    }
+  }
+
   bootstrap = async () => {
     logger.info('Bootstrapping application');
     // make single instance

package/apps/desktop/src/main/core/__tests__/App.test.ts

@@ -28,7 +28,7 @@ vi.mock('electron', () => ({
   },
   nativeTheme: {
     on: vi.fn(),
-    shouldUseDarkColors: false,
+    themeSource: 'system',
   },
   protocol: {
     registerSchemesAsPrivileged: vi.fn(),

package/apps/desktop/src/main/core/browser/Browser.ts

@@ -78,11 +78,9 @@ export default class Browser {
   /**
    * Get platform-specific theme configuration for window creation
    */
-  private getPlatformThemeConfig(isDarkMode?: boolean): Record<string, any> {
-    const darkMode = isDarkMode ?? nativeTheme.shouldUseDarkColors;
-
+  private getPlatformThemeConfig(): Record<string, any> {
     if (isWindows) {
-      return this.getWindowsThemeConfig(darkMode);
+      return this.getWindowsThemeConfig(this.isDarkMode);
     }
 
     return {};
@@ -164,10 +162,7 @@ export default class Browser {
   }
 
   private get isDarkMode() {
-    const themeMode = this.app.storeManager.get('themeMode');
-    if (themeMode === 'auto') return nativeTheme.shouldUseDarkColors;
-
-    return themeMode === 'dark';
+    return nativeTheme.shouldUseDarkColors;
   }
 
   loadUrl = async (path: string) => {
@@ -328,13 +323,11 @@ export default class Browser {
       `[${this.identifier}] Saved window state (only size used): ${JSON.stringify(savedState)}`,
     );
 
-    const isDarkMode = nativeTheme.shouldUseDarkColors;
-
     const browserWindow = new BrowserWindow({
       ...res,
       autoHideMenuBar: true,
       backgroundColor: '#00000000',
-      darkTheme: isDarkMode,
+      darkTheme: this.isDarkMode,
       frame: false,
       height: savedState?.height || height,
       show: false,
@@ -348,7 +341,7 @@ export default class Browser {
         sandbox: false,
       },
       width: savedState?.width || width,
-      ...this.getPlatformThemeConfig(isDarkMode),
+      ...this.getPlatformThemeConfig(),
     });
 
     this._browserWindow = browserWindow;

package/apps/desktop/src/main/core/browser/__tests__/Browser.test.ts

@@ -53,6 +53,7 @@ const { mockBrowserWindow, mockNativeTheme, mockIpcMain, mockScreen, MockBrowser
         off: vi.fn(),
         on: vi.fn(),
         shouldUseDarkColors: false,
+        themeSource: 'system',
       },
       mockScreen: {
         getDisplayNearestPoint: vi.fn().mockReturnValue({
@@ -272,7 +273,7 @@ describe('Browser', () => {
 
   describe('theme management', () => {
     describe('getPlatformThemeConfig', () => {
-      it('should return Windows dark theme config', () => {
+      it('should return Windows dark theme config when shouldUseDarkColors is true', () => {
         mockNativeTheme.shouldUseDarkColors = true;
 
         // Create browser with dark mode
@@ -289,7 +290,7 @@ describe('Browser', () => {
         );
       });
 
-      it('should return Windows light theme config', () => {
+      it('should return Windows light theme config when shouldUseDarkColors is false', () => {
         mockNativeTheme.shouldUseDarkColors = false;
 
         expect(MockBrowserWindow).toHaveBeenCalledWith(
@@ -334,11 +335,8 @@ describe('Browser', () => {
     });
 
     describe('isDarkMode', () => {
-      it('should return true when themeMode is dark', () => {
-        mockStoreManagerGet.mockImplementation((key: string) => {
-          if (key === 'themeMode') return 'dark';
-          return undefined;
-        });
+      it('should return true when shouldUseDarkColors is true', () => {
+        mockNativeTheme.shouldUseDarkColors = true;
 
         const darkBrowser = new Browser(defaultOptions, mockApp);
         // Access private getter through handleAppThemeChange which uses isDarkMode
@@ -348,18 +346,14 @@ describe('Browser', () => {
         expect(mockBrowserWindow.setBackgroundColor).toHaveBeenCalledWith('#1a1a1a');
       });
 
-      it('should use system theme when themeMode is auto', () => {
-        mockStoreManagerGet.mockImplementation((key: string) => {
-          if (key === 'themeMode') return 'auto';
-          return undefined;
-        });
-        mockNativeTheme.shouldUseDarkColors = true;
+      it('should return false when shouldUseDarkColors is false', () => {
+        mockNativeTheme.shouldUseDarkColors = false;
 
-        const autoBrowser = new Browser(defaultOptions, mockApp);
-        autoBrowser.handleAppThemeChange();
+        const lightBrowser = new Browser(defaultOptions, mockApp);
+        lightBrowser.handleAppThemeChange();
         vi.advanceTimersByTime(0);
 
-        expect(mockBrowserWindow.setBackgroundColor).toHaveBeenCalledWith('#1a1a1a');
+        expect(mockBrowserWindow.setBackgroundColor).toHaveBeenCalledWith('#ffffff');
       });
     });
   });

package/apps/desktop/src/main/core/ui/TrayManager.ts

@@ -57,7 +57,7 @@ export class TrayManager {
     logger.debug('初始化主托盘');
     return this.retrieveOrInitialize({
       iconPath: isMac
-        ? nativeTheme.shouldUseDarkColors
+        ? nativeTheme.shouldUseDarkColorsForSystemIntegratedUI
           ? 'tray-dark.png'
           : 'tray-light.png'
         : 'tray.png',

package/apps/desktop/src/main/core/ui/__tests__/TrayManager.test.ts

@@ -8,7 +8,7 @@ import { TrayManager } from '../TrayManager';
 // Mock electron modules
 vi.mock('electron', () => ({
   nativeTheme: {
-    shouldUseDarkColors: false,
+    shouldUseDarkColorsForSystemIntegratedUI: false,
   },
 }));
 
@@ -90,7 +90,7 @@ describe('TrayManager', () => {
 
   describe('initializeMainTray', () => {
     it('should create main tray with dark icon on macOS when dark mode is enabled', () => {
-      Object.defineProperty(nativeTheme, 'shouldUseDarkColors', {
+      Object.defineProperty(nativeTheme, 'shouldUseDarkColorsForSystemIntegratedUI', {
         value: true,
         writable: true,
         configurable: true,
@@ -110,7 +110,7 @@ describe('TrayManager', () => {
     });
 
     it('should create main tray with light icon on macOS when light mode is enabled', () => {
-      Object.defineProperty(nativeTheme, 'shouldUseDarkColors', {
+      Object.defineProperty(nativeTheme, 'shouldUseDarkColorsForSystemIntegratedUI', {
         value: false,
         writable: true,
         configurable: true,

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "features": [
+        "Add new provider Xiaomi MiMo."
+      ]
+    },
+    "date": "2026-01-04",
+    "version": "2.0.0-next.204"
+  },
   {
     "children": {
       "improvements": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.203",
+  "version": "2.0.0-next.204",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/packages/model-bank/package.json

@@ -71,6 +71,7 @@
     "./volcengine": "./src/aiModels/volcengine.ts",
     "./wenxin": "./src/aiModels/wenxin.ts",
     "./xai": "./src/aiModels/xai.ts",
+    "./xiaomimimo": "./src/aiModels/xiaomimimo.ts",
     "./xinference": "./src/aiModels/xinference.ts",
     "./zenmux": "./src/aiModels/zenmux.ts",
     "./zeroone": "./src/aiModels/zeroone.ts",

package/packages/model-bank/src/aiModels/index.ts

@@ -66,6 +66,7 @@ import { default as vllm } from './vllm';
 import { default as volcengine } from './volcengine';
 import { default as wenxin } from './wenxin';
 import { default as xai } from './xai';
+import { default as xiaomimimo } from './xiaomimimo';
 import { default as xinference } from './xinference';
 import { default as zenmux } from './zenmux';
 import { default as zeroone } from './zeroone';
@@ -156,6 +157,7 @@ export const LOBE_DEFAULT_MODEL_LIST = buildDefaultModelList({
   volcengine,
   wenxin,
   xai,
+  xiaomimimo,
   xinference,
   zenmux,
   zeroone,
@@ -227,6 +229,7 @@ export { default as vllm } from './vllm';
 export { default as volcengine } from './volcengine';
 export { default as wenxin } from './wenxin';
 export { default as xai } from './xai';
+export { default as xiaomimimo } from './xiaomimimo';
 export { default as xinference } from './xinference';
 export { default as zenmux } from './zenmux';
 export { default as zeroone } from './zeroone';

package/packages/model-bank/src/aiModels/xiaomimimo.ts

@@ -0,0 +1,24 @@
+import { AIChatModelCard } from '../types/aiModel';
+
+const xiaomimimoChatModels: AIChatModelCard[] = [
+  {
+    abilities: {
+      functionCall: true,
+      reasoning: true,
+    },
+    contextWindowTokens: 262_144,
+    description: 'MiMo-V2-Flash: An efficient model for reasoning, coding, and agent foundations.',
+    displayName: 'MiMo-V2 Flash',
+    enabled: true,
+    id: 'mimo-v2-flash',
+    maxOutput: 131_072,
+    settings: {
+      extendParams: ['enableReasoning'],
+    },
+    type: 'chat',
+  },
+];
+
+export const allModels = [...xiaomimimoChatModels];
+
+export default allModels;

package/packages/model-bank/src/const/modelProvider.ts

@@ -64,6 +64,7 @@ export enum ModelProvider {
   Volcengine = 'volcengine',
   Wenxin = 'wenxin',
   XAI = 'xai',
+  XiaomiMiMo = 'xiaomimimo',
   Xinference = 'xinference',
   ZenMux = 'zenmux',
   ZeroOne = 'zeroone',

package/packages/model-bank/src/modelProviders/index.ts

@@ -67,6 +67,7 @@ import VLLMProvider from './vllm';
 import VolcengineProvider from './volcengine';
 import WenxinProvider from './wenxin';
 import XAIProvider from './xai';
+import XiaomiMiMoProvider from './xiaomimimo';
 import XinferenceProvider from './xinference';
 import ZenMuxProvider from './zenmux';
 import ZeroOneProvider from './zeroone';
@@ -198,6 +199,7 @@ export const DEFAULT_MODEL_PROVIDER_LIST = [
   VercelAIGatewayProvider,
   CerebrasProvider,
   ZenMuxProvider,
+  XiaomiMiMoProvider,
 ];
 
 export const filterEnabledModels = (provider: ModelProviderCard) => {
@@ -274,6 +276,7 @@ export { default as VLLMProviderCard } from './vllm';
 export { default as VolcengineProviderCard } from './volcengine';
 export { default as WenxinProviderCard } from './wenxin';
 export { default as XAIProviderCard } from './xai';
+export { default as XiaomiMiMoProviderCard } from './xiaomimimo';
 export { default as XinferenceProviderCard } from './xinference';
 export { default as ZenMuxProviderCard } from './zenmux';
 export { default as ZeroOneProviderCard } from './zeroone';

package/packages/model-bank/src/modelProviders/xiaomimimo.ts

@@ -0,0 +1,22 @@
+import { type ModelProviderCard } from '@/types/llm';
+
+const XiaomiMiMo: ModelProviderCard = {
+  chatModels: [],
+  checkModel: 'mimo-v2-flash',
+  description:
+    'Xiaomi MiMo provides a conversational model service with an OpenAI-compatible API. The mimo-v2-flash model supports deep reasoning, streaming output, function calling, a 256K context window, and a maximum output of 128K.',
+  id: 'xiaomimimo',
+  modelList: { showModelFetcher: true },
+  name: 'Xiaomi MiMo',
+  settings: {
+    disableBrowserRequest: true, // CORS error
+    proxyUrl: {
+      placeholder: 'https://api.xiaomimimo.com/v1',
+    },
+    sdkType: 'openai',
+    showModelFetcher: true,
+  },
+  url: 'https://platform.xiaomimimo.com/',
+};
+
+export default XiaomiMiMo;

package/packages/model-runtime/src/index.ts

@@ -32,6 +32,7 @@ export { LobeQwenAI } from './providers/qwen';
 export { LobeStepfunAI } from './providers/stepfun';
 export { LobeTogetherAI } from './providers/togetherai';
 export { LobeVolcengineAI } from './providers/volcengine';
+export { LobeXiaomiMiMoAI } from './providers/xiaomimimo';
 export { LobeZenMuxAI } from './providers/zenmux';
 export { LobeZeroOneAI } from './providers/zeroone';
 export { LobeZhipuAI } from './providers/zhipu';

package/packages/model-runtime/src/providers/xiaomimimo/index.test.ts

@@ -0,0 +1,147 @@
+// @vitest-environment node
+import { ModelProvider } from 'model-bank';
+import { describe, expect, it, vi } from 'vitest';
+
+import { testProvider } from '../../providerTestUtils';
+import { LobeXiaomiMiMoAI, params } from './index';
+
+const provider = ModelProvider.XiaomiMiMo;
+const defaultBaseURL = 'https://api.xiaomimimo.com/v1';
+
+testProvider({
+  Runtime: LobeXiaomiMiMoAI,
+  provider,
+  defaultBaseURL,
+  chatDebugEnv: 'DEBUG_XIAOMIMIMO_CHAT_COMPLETION',
+  chatModel: 'gpt-4o',
+  test: {
+    skipAPICall: true,
+  },
+});
+
+describe('LobeXiaomiMiMoAI - custom features', () => {
+  describe('chatCompletion.handlePayload', () => {
+    it('should map max_tokens to max_completion_tokens', () => {
+      const payload = {
+        max_tokens: 1000,
+        model: 'gpt-4o',
+      };
+
+      const result = params.chatCompletion!.handlePayload!(payload as any);
+
+      expect(result.max_completion_tokens).toBe(1000);
+      expect(result.max_tokens).toBeUndefined();
+    });
+
+    it('should set stream to true by default', () => {
+      const payload = {
+        model: 'gpt-4o',
+      };
+
+      const result = params.chatCompletion!.handlePayload!(payload as any);
+
+      expect(result.stream).toBe(true);
+    });
+
+    it('should preserve existing stream value', () => {
+      const payload = {
+        model: 'gpt-4o',
+        stream: false,
+      };
+
+      const result = params.chatCompletion!.handlePayload!(payload as any);
+
+      expect(result.stream).toBe(false);
+    });
+
+    it('should clamp temperature between 0 and 1.5', () => {
+      const payloadLow = {
+        temperature: -1,
+        model: 'gpt-4o',
+      };
+      const resultLow = params.chatCompletion!.handlePayload!(payloadLow as any);
+      expect(resultLow.temperature).toBe(0);
+
+      const payloadHigh = {
+        temperature: 2,
+        model: 'gpt-4o',
+      };
+      const resultHigh = params.chatCompletion!.handlePayload!(payloadHigh as any);
+      expect(resultHigh.temperature).toBe(1.5);
+
+      const payloadNormal = {
+        temperature: 0.7,
+        model: 'gpt-4o',
+      };
+      const resultNormal = params.chatCompletion!.handlePayload!(payloadNormal as any);
+      expect(resultNormal.temperature).toBe(0.7);
+    });
+
+    it('should clamp top_p between 0.01 and 1', () => {
+      const payloadLow = {
+        top_p: 0,
+        model: 'gpt-4o',
+      };
+      const resultLow = params.chatCompletion!.handlePayload!(payloadLow as any);
+      expect(resultLow.top_p).toBe(0.01);
+
+      const payloadHigh = {
+        top_p: 1.5,
+        model: 'gpt-4o',
+      };
+      const resultHigh = params.chatCompletion!.handlePayload!(payloadHigh as any);
+      expect(resultHigh.top_p).toBe(1);
+
+      const payloadNormal = {
+        top_p: 0.5,
+        model: 'gpt-4o',
+      };
+      const resultNormal = params.chatCompletion!.handlePayload!(payloadNormal as any);
+      expect(resultNormal.top_p).toBe(0.5);
+    });
+
+    it('should handle thinking type enabled/disabled', () => {
+      const payloadEnabled = {
+        thinking: { type: 'enabled' },
+        model: 'gpt-4o',
+      };
+      const resultEnabled = params.chatCompletion!.handlePayload!(payloadEnabled as any);
+      expect(resultEnabled.thinking).toEqual({ type: 'enabled' });
+
+      const payloadDisabled = {
+        thinking: { type: 'disabled' },
+        model: 'gpt-4o',
+      };
+      const resultDisabled = params.chatCompletion!.handlePayload!(payloadDisabled as any);
+      expect(resultDisabled.thinking).toEqual({ type: 'disabled' });
+
+      const payloadOther = {
+        thinking: { type: 'other' },
+        model: 'gpt-4o',
+      };
+      const resultOther = params.chatCompletion!.handlePayload!(payloadOther as any);
+      expect(resultOther.thinking).toBeUndefined();
+    });
+  });
+
+  describe('models', () => {
+    it('should fetch and process model list', async () => {
+      const mockModels = [{ id: 'model-1' }, { id: 'model-2' }];
+      const client = {
+        models: {
+          list: vi.fn().mockResolvedValue({ data: mockModels }),
+        },
+      };
+
+      const result = await params.models!({ client: client as any });
+
+      expect(client.models.list).toHaveBeenCalled();
+      expect(result).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ id: 'model-1' }),
+          expect.objectContaining({ id: 'model-2' }),
+        ]),
+      );
+    });
+  });
+});

package/packages/model-runtime/src/providers/xiaomimimo/index.ts

@@ -0,0 +1,48 @@
+import { ModelProvider } from 'model-bank';
+
+import {
+  type OpenAICompatibleFactoryOptions,
+  createOpenAICompatibleRuntime,
+} from '../../core/openaiCompatibleFactory';
+import { MODEL_LIST_CONFIGS, processModelList } from '../../utils/modelParse';
+
+const clamp = (value: number, min: number, max: number) => Math.min(max, Math.max(min, value));
+
+export interface XiaomiMiMoModelCard {
+  id: string;
+}
+
+export const params = {
+  baseURL: 'https://api.xiaomimimo.com/v1',
+  chatCompletion: {
+    handlePayload: (payload) => {
+      const { thinking, temperature, top_p, max_tokens, stream, ...rest } = payload as any;
+      const thinkingType = thinking?.type;
+
+      return {
+        ...rest,
+        max_completion_tokens: max_tokens,
+        stream: stream ?? true,
+        ...(typeof temperature === 'number'
+          ? { temperature: clamp(temperature, 0, 1.5) }
+          : undefined),
+        ...(typeof top_p === 'number' ? { top_p: clamp(top_p, 0.01, 1) } : undefined),
+        ...(thinkingType === 'enabled' || thinkingType === 'disabled'
+          ? { thinking: { type: thinkingType } }
+          : undefined),
+      } as any;
+    },
+  },
+  debug: {
+    chatCompletion: () => process.env.DEBUG_XIAOMIMIMO_CHAT_COMPLETION === '1',
+  },
+  models: async ({ client }) => {
+    const modelsPage = (await client.models.list()) as any;
+    const modelList: XiaomiMiMoModelCard[] = modelsPage.data;
+
+    return processModelList(modelList, MODEL_LIST_CONFIGS.xiaomimimo, 'xiaomimimo');
+  },
+  provider: ModelProvider.XiaomiMiMo,
+} satisfies OpenAICompatibleFactoryOptions;
+
+export const LobeXiaomiMiMoAI = createOpenAICompatibleRuntime(params);

package/packages/model-runtime/src/runtimeMap.ts

@@ -62,6 +62,7 @@ import { LobeVLLMAI } from './providers/vllm';
 import { LobeVolcengineAI } from './providers/volcengine';
 import { LobeWenxinAI } from './providers/wenxin';
 import { LobeXAI } from './providers/xai';
+import { LobeXiaomiMiMoAI } from './providers/xiaomimimo';
 import { LobeXinferenceAI } from './providers/xinference';
 import { LobeZenMuxAI } from './providers/zenmux';
 import { LobeZeroOneAI } from './providers/zeroone';
@@ -133,6 +134,7 @@ export const providerRuntimeMap = {
   volcengine: LobeVolcengineAI,
   wenxin: LobeWenxinAI,
   xai: LobeXAI,
+  xiaomimimo: LobeXiaomiMiMoAI,
   xinference: LobeXinferenceAI,
   zenmux: LobeZenMuxAI,
   zeroone: LobeZeroOneAI,

package/packages/model-runtime/src/utils/modelParse.ts

@@ -120,6 +120,11 @@ export const MODEL_LIST_CONFIGS = {
     reasoningKeywords: ['mini', 'grok-4', 'grok-code-fast', '!non-reasoning'],
     visionKeywords: ['vision', 'grok-4'],
   },
+  xiaomimimo: {
+    functionCallKeywords: ['mimo'],
+    reasoningKeywords: ['mimo'],
+    visionKeywords: [],
+  },
   zeroone: {
     functionCallKeywords: ['fc'],
     visionKeywords: ['vision'],
@@ -149,6 +154,7 @@ export const MODEL_OWNER_DETECTION_CONFIG = {
   volcengine: ['doubao'],
   wenxin: ['ernie', 'qianfan'],
   xai: ['grok'],
+  xiaomimimo: ['mimo-'],
   zeroone: ['yi-'],
   zhipu: ['glm'],
 } as const;

package/src/envs/llm.ts

@@ -216,6 +216,9 @@ export const getLLMConfig = () => {
       ZENMUX_API_KEY: z.string().optional(),
 
       ENABLED_LOBEHUB: z.boolean(),
+
+      ENABLED_XIAOMIMIMO: z.boolean(),
+      XIAOMIMIMO_API_KEY: z.string().optional(),
     },
     runtimeEnv: {
       API_KEY_SELECT_MODE: process.env.API_KEY_SELECT_MODE,
@@ -430,6 +433,9 @@ export const getLLMConfig = () => {
       ZENMUX_API_KEY: process.env.ZENMUX_API_KEY,
 
       ENABLED_LOBEHUB: !!process.env.ENABLED_LOBEHUB,
+
+      ENABLED_XIAOMIMIMO: !!process.env.XIAOMIMIMO_API_KEY,
+      XIAOMIMIMO_API_KEY: process.env.XIAOMIMIMO_API_KEY,
     },
   });
 };

package/src/features/ElectronTitlebar/hooks/useWatchThemeUpdate.ts

@@ -7,6 +7,10 @@ import { useGlobalStore } from '@/store/global';
 import { systemStatusSelectors } from '@/store/global/selectors';
 import { ensureElectronIpc } from '@/utils/electron/ipc';
 
+const sidebarColors = {
+  dark: '#000',
+  light: '#f8f8f8',
+};
 export const useWatchThemeUpdate = () => {
   const [isAppStateInit, systemAppearance, updateElectronAppState, isMac] = useElectronStore(
     (s) => [
@@ -43,8 +47,9 @@ export const useWatchThemeUpdate = () => {
 
     const lobeApp = document.querySelector('#' + LOBE_THEME_APP_ID);
     if (!lobeApp) return;
-    const hexColor = getComputedStyle(lobeApp).getPropertyValue('--ant-color-bg-layout');
 
-    document.body.style.background = `color-mix(in srgb, ${hexColor} 86%, transparent)`;
+    if (systemAppearance) {
+      document.body.style.background = `color-mix(in srgb, ${sidebarColors[systemAppearance as 'dark' | 'light']} 86%, transparent)`;
+    }
   }, [systemAppearance, isAppStateInit, isMac]);
 };