@lobehub/chat 1.53.5 → 1.53.6

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+### [Version 1.53.6](https://github.com/lobehub/lobe-chat/compare/v1.53.5...v1.53.6)
+
+<sup>Released on **2025-02-13**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix not enable models correctly.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Fix not enable models correctly, closes [#6071](https://github.com/lobehub/lobe-chat/issues/6071) ([b78328e](https://github.com/lobehub/lobe-chat/commit/b78328e))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 1.53.5](https://github.com/lobehub/lobe-chat/compare/v1.53.4...v1.53.5)
 
 <sup>Released on **2025-02-13**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "fixes": [
+        "Fix not enable models correctly."
+      ]
+    },
+    "date": "2025-02-13",
+    "version": "1.53.6"
+  },
   {
     "children": {
       "fixes": [

package/docs/self-hosting/environment-variables/auth.mdx

@@ -19,6 +19,16 @@ LobeChat provides a complete authentication service capability when deployed. Th
 
 ### General Settings
 
+#### `NEXT_PUBLIC_ENABLE_NEXT_AUTH`
+
+- Changes after v1.52.0.
+
+- For users who deploy with Vercel using Next Auth, it is necessary to add the environment variable NEXT_PUBLIC_ENABLE_NEXT_AUTH=1 to ensure that Next Auth is enabled.
+- For users who use Clerk in their self-built image, it is necessary to configure the environment variable NEXT_PUBLIC_ENABLE_NEXT_AUTH=0 to disable Next Auth.\n
+- Other standard deployment scenarios (using Clerk on Vercel and next-auth in Docker) are not affected
+
+
+
 #### `NEXT_AUTH_SECRET`
 
 - Type: Required

package/docs/self-hosting/environment-variables/auth.zh-CN.mdx

@@ -17,6 +17,12 @@ LobeChat 在部署时提供了完善的身份验证服务能力，以下是相
 
 ### 通用设置
 
+#### `NEXT_PUBLIC_ENABLE_NEXT_AUTH`
+- v1.52.0 之后有变更
+- 针对使用 Vercel 部署中使用 next-auth 的用户，需要额外添加 NEXT_PUBLIC_ENABLE_NEXT_AUTH=1 环境变量来确保开启 Next Auth
+- 针对使用自构建镜像中使用 clerk 的用户，需要额外配置 NEXT_PUBLIC_ENABLE_NEXT_AUTH=0 环境变量来关闭 Next Auth
+- 其他标准部署场景（Vercel 中使用 Clerk 与 Docker 中使用 next-auth ）不受影响
+
 #### `NEXT_AUTH_SECRET`
 
 - 类型：必选
@@ -280,4 +286,4 @@ LobeChat 在部署时提供了完善的身份验证服务能力，以下是相
 - 类型：必选
 - 描述： Clerk 应用程序的 Secret key。您可以在[这里](https://dashboard.clerk.com)访问，并导航到 API Keys 以查看。
 - 默认值：`-`
-- 示例： `sk_test_513Ma0P7IAWM1XMv4waxZjRYRajWTaCfJLjpEO3SD2` （测试环境） / `sk_live_eMMlHjwJvZFUfczFljSKqZdwQtLvmczmsJSNmdrpeZ`（生产环境）
+- 示例： `sk_test_513Ma0P7IAWM1XMv4waxZjRYRajWTaCfJLjpEO3SD2` （测试环境） / `sk_live_eMMlHjwJvZFUfczFljSKqZdwQtLvmczmsJSNmdrpeZ`（生产环境）

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.53.5",
+  "version": "1.53.6",
   "description": "Lobe Chat - an open-source, high-performance chatbot 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",
@@ -173,7 +173,7 @@
     "langfuse": "3.29.1",
     "langfuse-core": "3.29.1",
     "lodash-es": "^4.17.21",
-    "lucide-react": "^0.471.0",
+    "lucide-react": "^0.475.0",
     "mammoth": "^1.9.0",
     "mdast-util-to-markdown": "^2.1.2",
     "modern-screenshot": "^4.5.5",
@@ -245,7 +245,7 @@
   "devDependencies": {
     "@commitlint/cli": "^19.6.1",
     "@edge-runtime/vm": "^5.0.0",
-    "@huggingface/tasks": "^0.13.13",
+    "@huggingface/tasks": "^0.15.0",
     "@lobehub/i18n-cli": "^1.20.3",
     "@lobehub/lint": "^1.25.5",
     "@lobehub/seo-cli": "^1.4.3",

package/src/database/repositories/aiInfra/index.test.ts

@@ -0,0 +1,415 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { DEFAULT_MODEL_PROVIDER_LIST } from '@/config/modelProviders';
+import { clientDB, initializeDB } from '@/database/client/db';
+import { AiProviderModel } from '@/database/server/models/aiProvider';
+import { LobeChatDatabase } from '@/database/type';
+import { AiProviderModelListItem } from '@/types/aiModel';
+import {
+  AiProviderDetailItem,
+  AiProviderListItem,
+  AiProviderRuntimeConfig,
+  EnabledAiModel,
+  EnabledProvider,
+} from '@/types/aiProvider';
+
+import { AiInfraRepos } from './index';
+
+const userId = 'test-user-id';
+const mockProviderConfigs = {
+  openai: { enabled: true },
+  anthropic: { enabled: false },
+};
+
+let repo: AiInfraRepos;
+
+beforeEach(async () => {
+  await initializeDB();
+  vi.clearAllMocks();
+
+  repo = new AiInfraRepos(clientDB as any, userId, mockProviderConfigs);
+});
+
+describe('AiInfraRepos', () => {
+  describe('getAiProviderList', () => {
+    it('should merge builtin and user providers correctly', async () => {
+      const mockUserProviders = [
+        { id: 'openai', enabled: true, name: 'Custom OpenAI' },
+        { id: 'custom', enabled: true, name: 'Custom Provider' },
+      ] as AiProviderListItem[];
+
+      vi.spyOn(repo.aiProviderModel, 'getAiProviderList').mockResolvedValueOnce(mockUserProviders);
+
+      const result = await repo.getAiProviderList();
+
+      expect(result).toBeDefined();
+      expect(result.length).toBeGreaterThan(0);
+      // Verify the merge logic
+      const openaiProvider = result.find((p) => p.id === 'openai');
+      expect(openaiProvider).toMatchObject({ enabled: true, name: 'Custom OpenAI' });
+    });
+
+    it('should sort providers according to DEFAULT_MODEL_PROVIDER_LIST order', async () => {
+      vi.spyOn(repo.aiProviderModel, 'getAiProviderList').mockResolvedValue([]);
+
+      const result = await repo.getAiProviderList();
+
+      expect(result).toEqual(
+        expect.arrayContaining(
+          DEFAULT_MODEL_PROVIDER_LIST.map((item) =>
+            expect.objectContaining({
+              id: item.id,
+              source: 'builtin',
+            }),
+          ),
+        ),
+      );
+    });
+  });
+
+  describe('getUserEnabledProviderList', () => {
+    it('should return only enabled providers', async () => {
+      const mockProviders = [
+        { id: 'openai', enabled: true, name: 'OpenAI', sort: 1 },
+        { id: 'anthropic', enabled: false, name: 'Anthropic', sort: 2 },
+      ] as AiProviderListItem[];
+
+      vi.spyOn(repo, 'getAiProviderList').mockResolvedValue(mockProviders);
+
+      const result = await repo.getUserEnabledProviderList();
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        id: 'openai',
+        name: 'OpenAI',
+      });
+    });
+
+    it('should return only enabled provider', async () => {
+      const mockProviders = [
+        {
+          enabled: true,
+          id: 'openai',
+          logo: 'logo1',
+          name: 'OpenAI',
+          sort: 1,
+          source: 'builtin' as const,
+        },
+        {
+          enabled: false,
+          id: 'anthropic',
+          logo: 'logo2',
+          name: 'Anthropic',
+          sort: 2,
+          source: 'builtin' as const,
+        },
+      ];
+
+      vi.spyOn(repo.aiProviderModel, 'getAiProviderList').mockResolvedValue(mockProviders);
+
+      const result = await repo.getUserEnabledProviderList();
+
+      expect(result).toEqual([
+        {
+          id: 'openai',
+          logo: 'logo1',
+          name: 'OpenAI',
+          source: 'builtin',
+        },
+      ]);
+    });
+  });
+
+  describe('getEnabledModels', () => {
+    it('should merge and filter enabled models', async () => {
+      const mockProviders = [{ id: 'openai', enabled: true }] as AiProviderListItem[];
+      const mockAllModels = [
+        { id: 'gpt-4', providerId: 'openai', enabled: true },
+      ] as EnabledAiModel[];
+
+      vi.spyOn(repo, 'getAiProviderList').mockResolvedValue(mockProviders);
+      vi.spyOn(repo.aiModelModel, 'getAllModels').mockResolvedValue(mockAllModels);
+      vi.spyOn(repo as any, 'fetchBuiltinModels').mockResolvedValue([
+        { id: 'gpt-4', enabled: true, type: 'chat' },
+      ]);
+
+      const result = await repo.getEnabledModels();
+
+      expect(result).toBeDefined();
+      expect(result.length).toBeGreaterThan(0);
+      expect(result[0]).toMatchObject({
+        id: 'gpt-4',
+        providerId: 'openai',
+      });
+    });
+
+    it('should merge builtin and user models correctly', async () => {
+      const mockProviders = [
+        { enabled: true, id: 'openai', name: 'OpenAI', sort: 1, source: 'builtin' as const },
+      ];
+
+      const mockAllModels = [
+        {
+          abilities: { vision: true },
+          displayName: 'Custom GPT-4',
+          enabled: true,
+          id: 'gpt-4',
+          providerId: 'openai',
+          sort: 1,
+          type: 'chat' as const,
+          contextWindowTokens: 10,
+        },
+      ];
+
+      vi.spyOn(repo, 'getAiProviderList').mockResolvedValue(mockProviders);
+      vi.spyOn(repo.aiModelModel, 'getAllModels').mockResolvedValue(mockAllModels);
+      vi.spyOn(repo as any, 'fetchBuiltinModels').mockResolvedValue([
+        {
+          abilities: {},
+          displayName: 'GPT-4',
+          enabled: true,
+          id: 'gpt-4',
+          type: 'chat' as const,
+        },
+      ]);
+
+      const result = await repo.getEnabledModels();
+
+      expect(result).toContainEqual(
+        expect.objectContaining({
+          abilities: { vision: true },
+          displayName: 'Custom GPT-4',
+          enabled: true,
+          contextWindowTokens: 10,
+          id: 'gpt-4',
+          providerId: 'openai',
+          sort: 1,
+          type: 'chat',
+        }),
+      );
+    });
+
+    it('should handle case when user model not found', async () => {
+      const mockProviders = [
+        { enabled: true, id: 'openai', name: 'OpenAI', sort: 1, source: 'builtin' as const },
+      ];
+
+      const mockAllModels: any[] = [];
+
+      vi.spyOn(repo, 'getAiProviderList').mockResolvedValue(mockProviders);
+      vi.spyOn(repo.aiModelModel, 'getAllModels').mockResolvedValue(mockAllModels);
+      vi.spyOn(repo as any, 'fetchBuiltinModels').mockResolvedValue([
+        {
+          abilities: { reasoning: true },
+          displayName: 'GPT-4',
+          enabled: true,
+          id: 'gpt-4',
+          type: 'chat' as const,
+        },
+      ]);
+
+      const result = await repo.getEnabledModels();
+
+      expect(result[0]).toEqual(
+        expect.objectContaining({
+          abilities: { reasoning: true },
+          enabled: true,
+          id: 'gpt-4',
+          providerId: 'openai',
+        }),
+      );
+    });
+  });
+
+  describe('getAiProviderModelList', () => {
+    it('should merge builtin and user models', async () => {
+      const providerId = 'openai';
+      const mockUserModels = [
+        { id: 'custom-gpt4', enabled: true, type: 'chat' },
+      ] as AiProviderModelListItem[];
+      const mockBuiltinModels = [{ id: 'gpt-4', enabled: true }];
+
+      vi.spyOn(repo.aiModelModel, 'getModelListByProviderId').mockResolvedValue(mockUserModels);
+      vi.spyOn(repo as any, 'fetchBuiltinModels').mockResolvedValue(mockBuiltinModels);
+
+      const result = await repo.getAiProviderModelList(providerId);
+
+      expect(result).toHaveLength(2);
+      expect(result).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ id: 'custom-gpt4' }),
+          expect.objectContaining({ id: 'gpt-4' }),
+        ]),
+      );
+    });
+    it('should merge default and custom models', async () => {
+      const mockCustomModels = [
+        {
+          displayName: 'Custom GPT-4',
+          enabled: false,
+          id: 'gpt-4',
+          type: 'chat' as const,
+        },
+      ];
+
+      const mockDefaultModels = [
+        {
+          displayName: 'GPT-4',
+          enabled: true,
+          id: 'gpt-4',
+          type: 'chat' as const,
+        },
+      ];
+
+      vi.spyOn(repo.aiModelModel, 'getModelListByProviderId').mockResolvedValue(mockCustomModels);
+      vi.spyOn(repo as any, 'fetchBuiltinModels').mockResolvedValue(mockDefaultModels);
+
+      const result = await repo.getAiProviderModelList('openai');
+
+      expect(result).toContainEqual(
+        expect.objectContaining({
+          displayName: 'Custom GPT-4',
+          enabled: false,
+          id: 'gpt-4',
+        }),
+      );
+    });
+
+    it('should use builtin models', async () => {
+      const providerId = 'taichu';
+
+      vi.spyOn(repo.aiModelModel, 'getModelListByProviderId').mockResolvedValue([]);
+
+      const result = await repo.getAiProviderModelList(providerId);
+
+      expect(result).toHaveLength(2);
+      expect(result).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ id: 'taichu_llm' }),
+          expect.objectContaining({ id: 'taichu2_mm' }),
+        ]),
+      );
+    });
+
+    it('should return empty if not exist provider', async () => {
+      const providerId = 'abc';
+
+      vi.spyOn(repo.aiModelModel, 'getModelListByProviderId').mockResolvedValue([]);
+
+      const result = await repo.getAiProviderModelList(providerId);
+
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('getAiProviderRuntimeState', () => {
+    it('should return complete runtime state', async () => {
+      const mockRuntimeConfig = {
+        openai: { apiKey: 'test-key' },
+      } as unknown as Record<string, AiProviderRuntimeConfig>;
+      const mockEnabledProviders = [{ id: 'openai', name: 'OpenAI' }] as EnabledProvider[];
+      const mockEnabledModels = [{ id: 'gpt-4', providerId: 'openai' }] as EnabledAiModel[];
+
+      vi.spyOn(repo.aiProviderModel, 'getAiProviderRuntimeConfig').mockResolvedValue(
+        mockRuntimeConfig,
+      );
+      vi.spyOn(repo, 'getUserEnabledProviderList').mockResolvedValue(mockEnabledProviders);
+      vi.spyOn(repo, 'getEnabledModels').mockResolvedValue(mockEnabledModels);
+
+      const result = await repo.getAiProviderRuntimeState();
+
+      expect(result).toMatchObject({
+        enabledAiProviders: mockEnabledProviders,
+        enabledAiModels: mockEnabledModels,
+        runtimeConfig: expect.any(Object),
+      });
+    });
+    it('should return provider runtime state', async () => {
+      const mockRuntimeConfig = {
+        openai: {
+          apiKey: 'test-key',
+        },
+      } as unknown as Record<string, AiProviderRuntimeConfig>;
+
+      vi.spyOn(repo.aiProviderModel, 'getAiProviderRuntimeConfig').mockResolvedValue(
+        mockRuntimeConfig,
+      );
+
+      vi.spyOn(repo, 'getUserEnabledProviderList').mockResolvedValue([
+        { id: 'openai', logo: 'logo1', name: 'OpenAI', source: 'builtin' },
+      ]);
+
+      vi.spyOn(repo, 'getEnabledModels').mockResolvedValue([
+        {
+          abilities: {},
+          enabled: true,
+          id: 'gpt-4',
+          providerId: 'openai',
+          type: 'chat',
+        },
+      ]);
+
+      const result = await repo.getAiProviderRuntimeState();
+
+      expect(result).toEqual({
+        enabledAiModels: [
+          expect.objectContaining({
+            enabled: true,
+            id: 'gpt-4',
+            providerId: 'openai',
+          }),
+        ],
+        enabledAiProviders: [{ id: 'openai', logo: 'logo1', name: 'OpenAI', source: 'builtin' }],
+        runtimeConfig: {
+          openai: {
+            apiKey: 'test-key',
+            enabled: true,
+          },
+        },
+      });
+    });
+  });
+
+  describe('getAiProviderDetail', () => {
+    it('should merge provider config with user settings', async () => {
+      const providerId = 'openai';
+      const mockProviderDetail = {
+        id: providerId,
+        customSetting: 'test',
+      } as unknown as AiProviderDetailItem;
+
+      vi.spyOn(repo.aiProviderModel, 'getAiProviderById').mockResolvedValue(mockProviderDetail);
+
+      const result = await repo.getAiProviderDetail(providerId);
+
+      expect(result).toMatchObject({
+        id: providerId,
+        customSetting: 'test',
+        enabled: true, // from mockProviderConfigs
+      });
+    });
+    it('should merge provider configs correctly', async () => {
+      const mockProviderDetail = {
+        enabled: true,
+        id: 'openai',
+        keyVaults: { apiKey: 'test-key' },
+        name: 'Custom OpenAI',
+        settings: {},
+        source: 'builtin' as const,
+      };
+
+      vi.spyOn(repo.aiProviderModel, 'getAiProviderById').mockResolvedValue(mockProviderDetail);
+
+      const result = await repo.getAiProviderDetail('openai');
+
+      expect(result).toEqual({
+        enabled: true,
+        id: 'openai',
+        keyVaults: { apiKey: 'test-key' },
+        name: 'Custom OpenAI',
+        settings: {},
+        source: 'builtin',
+      });
+    });
+  });
+});

package/src/database/repositories/aiInfra/index.ts

@@ -11,6 +11,7 @@ import {
   AiProviderListItem,
   AiProviderRuntimeState,
   EnabledAiModel,
+  EnabledProvider,
 } from '@/types/aiProvider';
 import { ProviderConfig } from '@/types/user/settings';
 import { merge, mergeArrayById } from '@/utils/merge';
@@ -22,7 +23,7 @@ export class AiInfraRepos {
   private db: LobeChatDatabase;
   aiProviderModel: AiProviderModel;
   private providerConfigs: Record<string, ProviderConfig>;
-  private aiModelModel: AiModelModel;
+  aiModelModel: AiModelModel;
 
   constructor(
     db: LobeChatDatabase,
@@ -70,7 +71,14 @@ export class AiInfraRepos {
     return list
       .filter((item) => item.enabled)
       .sort((a, b) => a.sort! - b.sort!)
-      .map((item) => ({ id: item.id, logo: item.logo, name: item.name, source: item.source }));
+      .map(
+        (item): EnabledProvider => ({
+          id: item.id,
+          logo: item.logo,
+          name: item.name,
+          source: item.source,
+        }),
+      );
   };
 
   getEnabledModels = async () => {
@@ -104,7 +112,7 @@ export class AiInfraRepos {
                   ? user.contextWindowTokens
                   : item.contextWindowTokens,
               displayName: user?.displayName || item.displayName,
-              enabled: user.enabled || item.enabled,
+              enabled: typeof user.enabled === 'boolean' ? user.enabled : item.enabled,
               id: item.id,
               providerId: provider.id,
               sort: user.sort || undefined,

package/src/libs/agent-runtime/providerTestUtils.test.ts

@@ -0,0 +1,123 @@
+import OpenAI from 'openai';
+import { describe, expect, it, vi } from 'vitest';
+
+import { testProvider } from './providerTestUtils';
+
+describe('testProvider', () => {
+  it('should run provider tests correctly', () => {
+    class MockRuntime {
+      baseURL: string;
+      client: any;
+
+      constructor({
+        apiKey,
+        baseURL = 'https://default.test',
+      }: {
+        apiKey?: string;
+        baseURL?: string;
+      }) {
+        if (!apiKey) throw { errorType: 'InvalidAPIKey' };
+        this.baseURL = baseURL;
+        this.client = {
+          chat: {
+            completions: {
+              create: vi.fn().mockResolvedValue(new ReadableStream()),
+            },
+          },
+        };
+      }
+
+      async chat(params: any) {
+        return this.client.chat.completions.create(params);
+      }
+    }
+
+    testProvider({
+      Runtime: MockRuntime,
+      bizErrorType: 'TestBizError',
+      chatDebugEnv: 'TEST_DEBUG',
+      chatModel: 'test-model',
+      defaultBaseURL: 'https://default.test',
+      invalidErrorType: 'InvalidAPIKey',
+      provider: 'TestProvider',
+    });
+  });
+
+  it('should handle OpenAI API errors correctly', async () => {
+    class MockRuntime {
+      baseURL: string;
+      client: any;
+
+      constructor({ apiKey }: { apiKey?: string }) {
+        if (!apiKey) throw { errorType: 'InvalidAPIKey' };
+        this.baseURL = 'test';
+        this.client = {
+          chat: {
+            completions: {
+              create: vi.fn().mockRejectedValue(
+                new OpenAI.APIError(
+                  400,
+                  {
+                    error: { message: 'Test Error' },
+                    status: 400,
+                  },
+                  'Test Error',
+                  {},
+                ),
+              ),
+            },
+          },
+        };
+      }
+
+      async chat(params: any) {
+        return this.client.chat.completions.create(params);
+      }
+    }
+
+    testProvider({
+      Runtime: MockRuntime,
+      bizErrorType: 'TestBizError',
+      chatDebugEnv: 'TEST_DEBUG',
+      chatModel: 'test-model',
+      defaultBaseURL: 'test',
+      invalidErrorType: 'InvalidAPIKey',
+      provider: 'TestProvider',
+    });
+  });
+
+  it('should handle debug stream correctly', () => {
+    class MockRuntime {
+      baseURL: string;
+      client: any;
+
+      constructor({ apiKey }: { apiKey?: string }) {
+        if (!apiKey) throw { errorType: 'InvalidAPIKey' };
+        this.baseURL = 'test';
+        this.client = {
+          chat: {
+            completions: {
+              create: vi.fn().mockResolvedValue({
+                tee: () => [new ReadableStream(), { toReadableStream: () => new ReadableStream() }],
+              }),
+            },
+          },
+        };
+      }
+
+      async chat(params: any) {
+        return this.client.chat.completions.create(params);
+      }
+    }
+
+    testProvider({
+      Runtime: MockRuntime,
+      bizErrorType: 'TestBizError',
+      chatDebugEnv: 'TEST_DEBUG',
+      chatModel: 'test-model',
+      defaultBaseURL: 'test',
+      invalidErrorType: 'InvalidAPIKey',
+      provider: 'TestProvider',
+    });
+  });
+});

package/src/server/routers/lambda/aiProvider.test.ts

@@ -0,0 +1,200 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { AiInfraRepos } from '@/database/repositories/aiInfra';
+import { serverDB } from '@/database/server';
+import { AiProviderModel } from '@/database/server/models/aiProvider';
+import { UserModel } from '@/database/server/models/user';
+import { getServerGlobalConfig } from '@/server/globalConfig';
+import { KeyVaultsGateKeeper } from '@/server/modules/KeyVaultsEncrypt';
+import { AiProviderDetailItem, AiProviderRuntimeState } from '@/types/aiProvider';
+
+import { aiProviderRouter } from './aiProvider';
+
+vi.mock('@/server/globalConfig');
+vi.mock('@/server/modules/KeyVaultsEncrypt');
+vi.mock('@/database/repositories/aiInfra');
+vi.mock('@/database/server/models/aiProvider');
+vi.mock('@/database/server/models/user');
+
+describe('aiProviderRouter', () => {
+  const mockUserId = 'test-user-id';
+  const mockProviderId = 'test-provider-id';
+  const mockEncrypt = vi.fn();
+  const mockDecrypt = vi.fn();
+
+  const mockGateKeeper = {
+    encrypt: mockEncrypt,
+    decrypt: mockDecrypt,
+  };
+
+  const mockProviderDetail: AiProviderDetailItem = {
+    id: mockProviderId,
+    name: 'Test Provider',
+    enabled: true,
+    description: 'Test Description',
+    source: 'custom',
+    settings: {},
+  };
+
+  const mockRuntimeState: AiProviderRuntimeState = {
+    enabledAiModels: [],
+    enabledAiProviders: [],
+    runtimeConfig: {},
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    vi.mocked(getServerGlobalConfig).mockReturnValue({
+      aiProvider: {},
+    } as any);
+
+    vi.mocked(KeyVaultsGateKeeper.initWithEnvKey).mockResolvedValue(mockGateKeeper as any);
+  });
+
+  const createMockContext = () => ({
+    userId: mockUserId,
+  });
+
+  describe('createAiProvider', () => {
+    it('should create a new AI provider', async () => {
+      const mockCreate = vi.fn().mockResolvedValue({ id: mockProviderId });
+      vi.mocked(AiProviderModel).prototype.create = mockCreate;
+
+      const caller = aiProviderRouter.createCaller(createMockContext());
+      const result = await caller.createAiProvider({
+        id: mockProviderId,
+        name: 'Test Provider',
+        source: 'custom',
+      });
+
+      expect(result).toBe(mockProviderId);
+      expect(mockCreate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          id: mockProviderId,
+          name: 'Test Provider',
+        }),
+        mockGateKeeper.encrypt,
+      );
+    });
+  });
+
+  describe('getAiProviderById', () => {
+    it('should get AI provider by id', async () => {
+      const mockGetDetail = vi.fn().mockResolvedValue(mockProviderDetail);
+      vi.mocked(AiInfraRepos).prototype.getAiProviderDetail = mockGetDetail;
+
+      const caller = aiProviderRouter.createCaller(createMockContext());
+      const result = await caller.getAiProviderById({ id: mockProviderId });
+
+      expect(result).toEqual(mockProviderDetail);
+      expect(mockGetDetail).toHaveBeenCalledWith(
+        mockProviderId,
+        KeyVaultsGateKeeper.getUserKeyVaults,
+      );
+    });
+  });
+
+  describe('getAiProviderList', () => {
+    it('should get AI provider list', async () => {
+      const mockList = [mockProviderDetail];
+      const mockGetList = vi.fn().mockResolvedValue(mockList);
+      vi.mocked(AiInfraRepos).prototype.getAiProviderList = mockGetList;
+
+      const caller = aiProviderRouter.createCaller(createMockContext());
+      const result = await caller.getAiProviderList();
+
+      expect(result).toEqual(mockList);
+      expect(mockGetList).toHaveBeenCalled();
+    });
+  });
+
+  describe('getAiProviderRuntimeState', () => {
+    it('should get AI provider runtime state', async () => {
+      const mockGetState = vi.fn().mockResolvedValue(mockRuntimeState);
+      vi.mocked(AiInfraRepos).prototype.getAiProviderRuntimeState = mockGetState;
+
+      const caller = aiProviderRouter.createCaller(createMockContext());
+      const result = await caller.getAiProviderRuntimeState({});
+
+      expect(result).toEqual(mockRuntimeState);
+      expect(mockGetState).toHaveBeenCalledWith(KeyVaultsGateKeeper.getUserKeyVaults);
+    });
+  });
+
+  describe('removeAiProvider', () => {
+    it('should remove AI provider', async () => {
+      const mockDelete = vi.fn();
+      vi.mocked(AiProviderModel).prototype.delete = mockDelete;
+
+      const caller = aiProviderRouter.createCaller(createMockContext());
+      await caller.removeAiProvider({ id: mockProviderId });
+
+      expect(mockDelete).toHaveBeenCalledWith(mockProviderId);
+    });
+  });
+
+  describe('toggleProviderEnabled', () => {
+    it('should toggle provider enabled state', async () => {
+      const mockToggle = vi.fn();
+      vi.mocked(AiProviderModel).prototype.toggleProviderEnabled = mockToggle;
+
+      const caller = aiProviderRouter.createCaller(createMockContext());
+      await caller.toggleProviderEnabled({
+        id: mockProviderId,
+        enabled: true,
+      });
+
+      expect(mockToggle).toHaveBeenCalledWith(mockProviderId, true);
+    });
+  });
+
+  describe('updateAiProvider', () => {
+    it('should update AI provider', async () => {
+      const mockUpdate = vi.fn();
+      vi.mocked(AiProviderModel).prototype.update = mockUpdate;
+
+      const caller = aiProviderRouter.createCaller(createMockContext());
+      await caller.updateAiProvider({
+        id: mockProviderId,
+        value: { name: 'Updated Provider' },
+      });
+
+      expect(mockUpdate).toHaveBeenCalledWith(mockProviderId, {
+        name: 'Updated Provider',
+      });
+    });
+  });
+
+  describe('updateAiProviderConfig', () => {
+    it('should update AI provider config', async () => {
+      const mockUpdateConfig = vi.fn();
+      vi.mocked(AiProviderModel).prototype.updateConfig = mockUpdateConfig;
+
+      const caller = aiProviderRouter.createCaller(createMockContext());
+      await caller.updateAiProviderConfig({
+        id: mockProviderId,
+        value: { checkModel: 'gpt-4' },
+      });
+
+      expect(mockUpdateConfig).toHaveBeenCalledWith(
+        mockProviderId,
+        { checkModel: 'gpt-4' },
+        mockGateKeeper.encrypt,
+      );
+    });
+  });
+
+  describe('updateAiProviderOrder', () => {
+    it('should update AI provider order', async () => {
+      const mockUpdateOrder = vi.fn();
+      vi.mocked(AiProviderModel).prototype.updateOrder = mockUpdateOrder;
+
+      const sortMap = [{ id: mockProviderId, sort: 1 }];
+      const caller = aiProviderRouter.createCaller(createMockContext());
+      await caller.updateAiProviderOrder({ sortMap });
+
+      expect(mockUpdateOrder).toHaveBeenCalledWith(sortMap);
+    });
+  });
+});