@lobehub/lobehub 2.0.0-next.200 → 2.0.0-next.202

package/packages/model-runtime/src/core/ModelRuntime.test.ts

@@ -1,18 +1,25 @@
 // @vitest-environment node
-import { TraceNameMap } from '@lobechat/types';
 import { ClientSecretPayload } from '@lobechat/types';
-import { Langfuse } from 'langfuse';
-import { LangfuseGenerationClient, LangfuseTraceClient } from 'langfuse-core';
 import { ModelProvider } from 'model-bank';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import * as langfuseCfg from '@/envs/langfuse';
-import { createTraceOptions } from '@/server/modules/ModelRuntime';
-
-import { ChatStreamPayload, LobeOpenAI, ModelRuntime } from '../index';
+import { ChatStreamCallbacks, ChatStreamPayload, LobeOpenAI, ModelRuntime } from '../index';
 import { providerRuntimeMap } from '../runtimeMap';
 import { CreateImagePayload } from '../types/image';
-import { AgentChatOptions } from './ModelRuntime';
+
+/**
+ * Mock createTraceOptions for testing purposes.
+ * This avoids importing from @/server/modules/ModelRuntime which has database dependencies.
+ */
+const createMockTraceOptions = (callbacks?: Partial<ChatStreamCallbacks>) => ({
+  callback: {
+    onCompletion: callbacks?.onCompletion ?? vi.fn(),
+    onFinal: callbacks?.onFinal ?? vi.fn(),
+    onStart: callbacks?.onStart ?? vi.fn(),
+    onToolsCalling: callbacks?.onToolsCalling ?? vi.fn(),
+  } as ChatStreamCallbacks,
+  headers: new Headers(),
+});
 
 const specialProviders = [
   { id: 'openai', payload: { apiKey: 'user-openai-key', baseURL: 'user-endpoint' } },
@@ -99,85 +106,50 @@ describe('ModelRuntime', () => {
 
       await mockModelRuntime.chat(payload);
     });
-    it('should handle options correctly', async () => {
+    it('should handle options with callbacks correctly', async () => {
       const payload: ChatStreamPayload = {
         messages: [{ role: 'user', content: 'Hello, world!' }],
         model: 'text-davinci-002',
         temperature: 0,
       };
 
-      const options: AgentChatOptions = {
-        provider: 'openai',
-        trace: {
-          traceId: 'test-trace-id',
-          traceName: TraceNameMap.SummaryTopicTitle,
-          sessionId: 'test-session-id',
-          topicId: 'test-topic-id',
-          tags: [],
-          userId: 'test-user-id',
-        },
-      };
-
       vi.spyOn(LobeOpenAI.prototype, 'chat').mockResolvedValue(new Response(''));
 
-      await mockModelRuntime.chat(payload, createTraceOptions(payload, options));
+      await mockModelRuntime.chat(payload, createMockTraceOptions());
     });
 
-    describe('callback', async () => {
+    describe('callback', () => {
       const payload: ChatStreamPayload = {
         messages: [{ role: 'user', content: 'Hello, world!' }],
         model: 'text-davinci-002',
         temperature: 0,
       };
 
-      const options: AgentChatOptions = {
-        provider: 'openai',
-        trace: {
-          traceId: 'test-trace-id',
-          traceName: TraceNameMap.SummaryTopicTitle,
-          sessionId: 'test-session-id',
-          topicId: 'test-topic-id',
-          tags: [],
-          userId: 'test-user-id',
-        },
-        enableTrace: true,
-      };
-
-      const updateMock = vi.fn();
-
       it('should call onToolsCalling correctly', async () => {
-        vi.spyOn(langfuseCfg, 'getLangfuseConfig').mockReturnValue({
-          ENABLE_LANGFUSE: true,
-          LANGFUSE_PUBLIC_KEY: 'abc',
-          LANGFUSE_SECRET_KEY: 'DDD',
-        } as any);
+        const onToolsCallingMock = vi.fn();
 
-        // 使用 spyOn 模拟 chat 方法
         vi.spyOn(LobeOpenAI.prototype, 'chat').mockImplementation(
-          async (payload, { callback }: any) => {
-            // 模拟 onToolCall 回调的触发
+          async (_payload, { callback }: any) => {
             if (callback?.onToolsCalling) {
               await callback.onToolsCalling();
             }
             return new Response('abc');
           },
         );
-        vi.spyOn(LangfuseTraceClient.prototype, 'update').mockImplementation(updateMock);
 
-        await mockModelRuntime.chat(payload, createTraceOptions(payload, options));
+        await mockModelRuntime.chat(
+          payload,
+          createMockTraceOptions({ onToolsCalling: onToolsCallingMock }),
+        );
 
-        expect(updateMock).toHaveBeenCalledWith({ tags: ['Tools Calling'] });
+        expect(onToolsCallingMock).toHaveBeenCalled();
       });
+
       it('should call onStart correctly', async () => {
-        vi.spyOn(langfuseCfg, 'getLangfuseConfig').mockReturnValue({
-          ENABLE_LANGFUSE: true,
-          LANGFUSE_PUBLIC_KEY: 'abc',
-          LANGFUSE_SECRET_KEY: 'DDD',
-        } as any);
+        const onStartMock = vi.fn();
 
-        vi.spyOn(LangfuseGenerationClient.prototype, 'update').mockImplementation(updateMock);
         vi.spyOn(LobeOpenAI.prototype, 'chat').mockImplementation(
-          async (payload, { callback }: any) => {
+          async (_payload, { callback }: any) => {
             if (callback?.onStart) {
               callback.onStart();
             }
@@ -185,22 +157,16 @@ describe('ModelRuntime', () => {
           },
         );
 
-        await mockModelRuntime.chat(payload, createTraceOptions(payload, options));
+        await mockModelRuntime.chat(payload, createMockTraceOptions({ onStart: onStartMock }));
 
-        // Verify onStart was called
-        expect(updateMock).toHaveBeenCalledWith({ completionStartTime: expect.any(Date) });
+        expect(onStartMock).toHaveBeenCalled();
       });
 
       it('should call onCompletion correctly', async () => {
-        vi.spyOn(langfuseCfg, 'getLangfuseConfig').mockReturnValue({
-          ENABLE_LANGFUSE: true,
-          LANGFUSE_PUBLIC_KEY: 'abc',
-          LANGFUSE_SECRET_KEY: 'DDD',
-        } as any);
-        // Spy on the chat method and trigger onCompletion callback
-        vi.spyOn(LangfuseGenerationClient.prototype, 'update').mockImplementation(updateMock);
+        const onCompletionMock = vi.fn();
+
         vi.spyOn(LobeOpenAI.prototype, 'chat').mockImplementation(
-          async (payload, { callback }: any) => {
+          async (_payload, { callback }: any) => {
             if (callback?.onCompletion) {
               await callback.onCompletion({ text: 'Test completion' });
             }
@@ -208,37 +174,29 @@ describe('ModelRuntime', () => {
           },
         );
 
-        await mockModelRuntime.chat(payload, createTraceOptions(payload, options));
+        await mockModelRuntime.chat(
+          payload,
+          createMockTraceOptions({ onCompletion: onCompletionMock }),
+        );
 
-        // Verify onCompletion was called with expected output
-        expect(updateMock).toHaveBeenCalledWith({
-          endTime: expect.any(Date),
-          metadata: {},
-          output: 'Test completion',
-        });
+        expect(onCompletionMock).toHaveBeenCalledWith({ text: 'Test completion' });
       });
-      it.skip('should call onFinal correctly', async () => {
-        vi.spyOn(langfuseCfg, 'getLangfuseConfig').mockReturnValue({
-          ENABLE_LANGFUSE: true,
-          LANGFUSE_PUBLIC_KEY: 'abc',
-          LANGFUSE_SECRET_KEY: 'DDD',
-        } as any);
+
+      it('should call onFinal correctly', async () => {
+        const onFinalMock = vi.fn();
 
         vi.spyOn(LobeOpenAI.prototype, 'chat').mockImplementation(
-          async (payload, { callback }: any) => {
+          async (_payload, { callback }: any) => {
             if (callback?.onFinal) {
               await callback.onFinal('Test completion');
             }
             return new Response('Success');
           },
         );
-        const shutdownAsyncMock = vi.fn();
-        vi.spyOn(Langfuse.prototype, 'shutdownAsync').mockImplementation(shutdownAsyncMock);
 
-        await mockModelRuntime.chat(payload, createTraceOptions(payload, options));
+        await mockModelRuntime.chat(payload, createMockTraceOptions({ onFinal: onFinalMock }));
 
-        // Verify onCompletion was called with expected output
-        expect(shutdownAsyncMock).toHaveBeenCalled();
+        expect(onFinalMock).toHaveBeenCalledWith('Test completion');
       });
     });
   });

package/packages/types/src/aiChat.ts

@@ -120,7 +120,6 @@ export const StructureSchema = z.object({
 });
 
 export const StructureOutputSchema = z.object({
-  keyVaultsPayload: z.string(),
   messages: z.array(z.any()),
   model: z.string(),
   provider: z.string(),

package/packages/types/src/message/ui/chat.ts

@@ -69,7 +69,7 @@ export interface TaskDetail {
   /** Execution duration in milliseconds */
   duration?: number;
   /** Error message if task failed */
-  error?: string;
+  error?: Record<string, any>;
   /** Task start time (ISO string) */
   startedAt?: string;
   /** Task status */

package/src/app/(backend)/middleware/auth/index.ts

@@ -15,6 +15,8 @@ import {
   enableBetterAuth,
   enableClerk,
 } from '@/const/auth';
+import { getServerDB } from '@/database/core/db-adaptor';
+import { type LobeChatDatabase } from '@/database/type';
 import { ClerkAuth } from '@/libs/clerk-auth';
 import { validateOIDCJWT } from '@/libs/oidc-provider/jwt';
 import { createErrorResponse } from '@/utils/errorResponse';
@@ -28,6 +30,8 @@ export type RequestHandler = (
   req: Request,
   options: RequestOptions & {
     jwtPayload: ClientSecretPayload;
+    serverDB: LobeChatDatabase;
+    userId: string;
   },
 ) => Promise<Response>;
 
@@ -38,10 +42,18 @@ export const checkAuth =
     // This ensures the handler can safely read the request body
     const clonedReq = req.clone();
 
+    // Get serverDB for database access
+    const serverDB = await getServerDB();
+
     // we have a special header to debug the api endpoint in development mode
     const isDebugApi = req.headers.get('lobe-auth-dev-backend-api') === '1';
     if (process.env.NODE_ENV === 'development' && isDebugApi) {
-      return handler(clonedReq, { ...options, jwtPayload: { userId: 'DEV_USER' } });
+      return handler(clonedReq, {
+        ...options,
+        jwtPayload: { userId: 'DEV_USER' },
+        serverDB,
+        userId: 'DEV_USER',
+      });
     }
 
     let jwtPayload: ClientSecretPayload;
@@ -124,5 +136,7 @@ export const checkAuth =
       return createErrorResponse(errorType, { error, ...res, provider: params?.provider });
     }
 
-    return handler(clonedReq, { ...options, jwtPayload });
+    const userId = jwtPayload.userId || '';
+
+    return handler(clonedReq, { ...options, jwtPayload, serverDB, userId });
   };

package/src/app/(backend)/webapi/chat/[provider]/route.test.ts

@@ -7,6 +7,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { checkAuthMethod } from '@/app/(backend)/middleware/auth/utils';
 import { LOBE_CHAT_AUTH_HEADER, OAUTH_AUTHORIZED } from '@/const/auth';
+import { initModelRuntimeFromDB } from '@/server/modules/ModelRuntime';
 
 import { POST } from './route';
 
@@ -22,6 +23,11 @@ vi.mock('@lobechat/utils/server', () => ({
   getXorPayload: vi.fn(),
 }));
 
+vi.mock('@/server/modules/ModelRuntime', () => ({
+  initModelRuntimeFromDB: vi.fn(),
+  createTraceOptions: vi.fn().mockReturnValue({}),
+}));
+
 // Use vi.hoisted to ensure mockState is initialized before mocks are set up
 const mockState = vi.hoisted(() => ({ enableClerk: false }));
 
@@ -60,7 +66,7 @@ describe('POST handler', () => {
     it('should initialize ModelRuntime correctly with valid authorization', async () => {
       const mockParams = Promise.resolve({ provider: 'test-provider' });
 
-      // 设置 getJWTPayload 和 initModelRuntimeWithUserPayload 的模拟返回值
+      // 设置 getJWTPayload 的模拟返回值
       vi.mocked(getXorPayload).mockReturnValueOnce({
         apiKey: 'test-api-key',
         azureApiVersion: 'v1',
@@ -68,17 +74,19 @@ describe('POST handler', () => {
 
       const mockRuntime: LobeRuntimeAI = { baseURL: 'abc', chat: vi.fn() };
 
-      // migrate to new ModelRuntime init api
-      const spy = vi
-        .spyOn(ModelRuntime, 'initializeWithProvider')
-        .mockResolvedValue(new ModelRuntime(mockRuntime));
+      // Mock initModelRuntimeFromDB
+      vi.mocked(initModelRuntimeFromDB).mockResolvedValue(new ModelRuntime(mockRuntime));
 
       // 调用 POST 函数
       await POST(request as unknown as Request, { params: mockParams });
 
       // 验证是否正确调用了模拟函数
       expect(getXorPayload).toHaveBeenCalledWith('Bearer some-valid-token');
-      expect(spy).toHaveBeenCalledWith('test-provider', expect.anything());
+      expect(initModelRuntimeFromDB).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.any(String),
+        'test-provider',
+      );
     });
 
     it('should return Unauthorized error when LOBE_CHAT_AUTH_HEADER is missing', async () => {
@@ -109,15 +117,13 @@ describe('POST handler', () => {
       });
 
       const mockParams = Promise.resolve({ provider: 'test-provider' });
-      // 设置 initModelRuntimeWithUserPayload 的模拟返回值
       vi.mocked(getAuth).mockReturnValue({} as any);
       vi.mocked(checkAuthMethod).mockReset();
 
       const mockRuntime: LobeRuntimeAI = { baseURL: 'abc', chat: vi.fn() };
 
-      vi.spyOn(ModelRuntime, 'initializeWithProvider').mockResolvedValue(
-        new ModelRuntime(mockRuntime),
-      );
+      // Mock initModelRuntimeFromDB
+      vi.mocked(initModelRuntimeFromDB).mockResolvedValue(new ModelRuntime(mockRuntime));
 
       const request = new Request(new URL('https://test.com'), {
         method: 'POST',
@@ -174,20 +180,23 @@ describe('POST handler', () => {
       });
 
       const mockChatResponse: any = { success: true, message: 'Reply from agent' };
+      const mockRuntime: LobeRuntimeAI = {
+        baseURL: 'abc',
+        chat: vi.fn().mockResolvedValue(mockChatResponse),
+      };
 
-      vi.spyOn(ModelRuntime.prototype, 'chat').mockResolvedValue(mockChatResponse);
+      vi.mocked(initModelRuntimeFromDB).mockResolvedValue(new ModelRuntime(mockRuntime));
 
       const response = await POST(request as unknown as Request, { params: mockParams });
 
       expect(response).toEqual(mockChatResponse);
-      expect(ModelRuntime.prototype.chat).toHaveBeenCalledWith(mockChatPayload, {
-        user: 'abc',
+      expect(mockRuntime.chat).toHaveBeenCalledWith(mockChatPayload, {
+        user: expect.any(String),
         signal: expect.anything(),
       });
     });
 
     it('should return an error response when chat completion fails', async () => {
-      // 设置 getJWTPayload 和 initAgentRuntimeWithUserPayload 的模拟返回值
       vi.mocked(getXorPayload).mockReturnValueOnce({
         apiKey: 'test-api-key',
         azureApiVersion: 'v1',
@@ -203,10 +212,16 @@ describe('POST handler', () => {
 
       const mockErrorResponse = {
         errorType: ChatErrorType.InternalServerError,
+        error: { errorMessage: 'Something went wrong', errorType: 500 },
         errorMessage: 'Something went wrong',
       };
 
-      vi.spyOn(ModelRuntime.prototype, 'chat').mockRejectedValue(mockErrorResponse);
+      const mockRuntime: LobeRuntimeAI = {
+        baseURL: 'abc',
+        chat: vi.fn().mockRejectedValue(mockErrorResponse),
+      };
+
+      vi.mocked(initModelRuntimeFromDB).mockResolvedValue(new ModelRuntime(mockRuntime));
 
       const response = await POST(request, { params: mockParams });
 

package/src/app/(backend)/webapi/chat/[provider]/route.ts

@@ -6,7 +6,7 @@ import {
 import { ChatErrorType } from '@lobechat/types';
 
 import { checkAuth } from '@/app/(backend)/middleware/auth';
-import { createTraceOptions, initModelRuntimeWithUserPayload } from '@/server/modules/ModelRuntime';
+import { createTraceOptions, initModelRuntimeFromDB } from '@/server/modules/ModelRuntime';
 import { type ChatStreamPayload } from '@/types/openai/chat';
 import { createErrorResponse } from '@/utils/errorResponse';
 import { getTracePayload } from '@/utils/trace';
@@ -15,48 +15,52 @@ import { getTracePayload } from '@/utils/trace';
 // this enforce user to enable fluid compute
 export const maxDuration = 300;
 
-export const POST = checkAuth(async (req: Request, { params, jwtPayload, createRuntime }) => {
-  const provider = (await params)!.provider!;
+export const POST = checkAuth(
+  async (req: Request, { params, userId, serverDB, createRuntime, jwtPayload }) => {
+    const provider = (await params)!.provider!;
 
-  try {
-    // ============  1. init chat model   ============ //
-    let modelRuntime: ModelRuntime;
-    if (createRuntime) {
-      modelRuntime = createRuntime(jwtPayload);
-    } else {
-      modelRuntime = await initModelRuntimeWithUserPayload(provider, jwtPayload);
-    }
+    try {
+      // ============  1. init chat model   ============ //
+      let modelRuntime: ModelRuntime;
+      if (createRuntime) {
+        // Legacy support for custom runtime creation
+        modelRuntime = createRuntime(jwtPayload);
+      } else {
+        // Read user's provider config from database
+        modelRuntime = await initModelRuntimeFromDB(serverDB, userId, provider);
+      }
 
-    // ============  2. create chat completion   ============ //
+      // ============  2. create chat completion   ============ //
 
-    const data = (await req.json()) as ChatStreamPayload;
+      const data = (await req.json()) as ChatStreamPayload;
 
-    const tracePayload = getTracePayload(req);
+      const tracePayload = getTracePayload(req);
 
-    let traceOptions = {};
-    // If user enable trace
-    if (tracePayload?.enabled) {
-      traceOptions = createTraceOptions(data, { provider, trace: tracePayload });
-    }
+      let traceOptions = {};
+      // If user enable trace
+      if (tracePayload?.enabled) {
+        traceOptions = createTraceOptions(data, { provider, trace: tracePayload });
+      }
+
+      return await modelRuntime.chat(data, {
+        user: userId,
+        ...traceOptions,
+        signal: req.signal,
+      });
+    } catch (e) {
+      const {
+        errorType = ChatErrorType.InternalServerError,
+        error: errorContent,
+        ...res
+      } = e as ChatCompletionErrorPayload;
 
-    return await modelRuntime.chat(data, {
-      user: jwtPayload.userId,
-      ...traceOptions,
-      signal: req.signal,
-    });
-  } catch (e) {
-    const {
-      errorType = ChatErrorType.InternalServerError,
-      error: errorContent,
-      ...res
-    } = e as ChatCompletionErrorPayload;
-
-    const error = errorContent || e;
-
-    const logMethod = AGENT_RUNTIME_ERROR_SET.has(errorType as string) ? 'warn' : 'error';
-    // track the error at server side
-    console[logMethod](`Route: [${provider}] ${errorType}:`, error);
-
-    return createErrorResponse(errorType, { error, ...res, provider });
-  }
-});
+      const error = errorContent || e;
+
+      const logMethod = AGENT_RUNTIME_ERROR_SET.has(errorType as string) ? 'warn' : 'error';
+      // track the error at server side
+      console[logMethod](`Route: [${provider}] ${errorType}:`, error);
+
+      return createErrorResponse(errorType, { error, ...res, provider });
+    }
+  },
+);

package/src/app/(backend)/webapi/models/[provider]/pull/route.ts

@@ -2,14 +2,15 @@ import { type ChatCompletionErrorPayload, type PullModelParams } from '@lobechat
 import { ChatErrorType } from '@lobechat/types';
 
 import { checkAuth } from '@/app/(backend)/middleware/auth';
-import { initModelRuntimeWithUserPayload } from '@/server/modules/ModelRuntime';
+import { initModelRuntimeFromDB } from '@/server/modules/ModelRuntime';
 import { createErrorResponse } from '@/utils/errorResponse';
 
-export const POST = checkAuth(async (req, { params, jwtPayload }) => {
+export const POST = checkAuth(async (req, { params, userId, serverDB }) => {
   const provider = (await params)!.provider!;
 
   try {
-    const agentRuntime = await initModelRuntimeWithUserPayload(provider, jwtPayload);
+    // Read user's provider config from database
+    const agentRuntime = await initModelRuntimeFromDB(serverDB, userId, provider);
 
     const data = (await req.json()) as PullModelParams;
 

package/src/app/(backend)/webapi/models/[provider]/route.test.ts

@@ -1,10 +1,11 @@
 // @vitest-environment node
-import { ModelRuntime } from '@lobechat/model-runtime';
+import { LobeRuntimeAI, ModelRuntime } from '@lobechat/model-runtime';
 import { ChatErrorType } from '@lobechat/types';
 import { getXorPayload } from '@lobechat/utils/server';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { LOBE_CHAT_AUTH_HEADER } from '@/const/auth';
+import { initModelRuntimeFromDB } from '@/server/modules/ModelRuntime';
 
 import { GET } from './route';
 
@@ -20,6 +21,10 @@ vi.mock('@lobechat/utils/server', () => ({
   getXorPayload: vi.fn(),
 }));
 
+vi.mock('@/server/modules/ModelRuntime', () => ({
+  initModelRuntimeFromDB: vi.fn(),
+}));
+
 let request: Request;
 
 beforeEach(() => {
@@ -48,9 +53,12 @@ describe('GET handler', () => {
       errorWithStack.stack =
         'Error: Something went wrong\n    at Object.<anonymous> (/path/to/file.ts:10:15)';
 
-      vi.spyOn(ModelRuntime, 'initializeWithProvider').mockResolvedValue({
+      const mockRuntime: LobeRuntimeAI = {
+        baseURL: 'abc',
+        chat: vi.fn(),
         models: vi.fn().mockRejectedValue(errorWithStack),
-      } as any);
+      };
+      vi.mocked(initModelRuntimeFromDB).mockResolvedValue(new ModelRuntime(mockRuntime));
 
       const response = await GET(request, { params: mockParams });
       const responseBody = await response.json();
@@ -85,9 +93,12 @@ describe('GET handler', () => {
       const customError = new CustomError('Custom error occurred');
       customError.stack = 'CustomError: Custom error occurred\n    at somewhere';
 
-      vi.spyOn(ModelRuntime, 'initializeWithProvider').mockResolvedValue({
+      const mockRuntime: LobeRuntimeAI = {
+        baseURL: 'abc',
+        chat: vi.fn(),
         models: vi.fn().mockRejectedValue(customError),
-      } as any);
+      };
+      vi.mocked(initModelRuntimeFromDB).mockResolvedValue(new ModelRuntime(mockRuntime));
 
       const response = await GET(request, { params: mockParams });
       const responseBody = await response.json();
@@ -109,9 +120,12 @@ describe('GET handler', () => {
         error: { code: 'PROVIDER_ERROR', details: 'API limit exceeded' },
       };
 
-      vi.spyOn(ModelRuntime, 'initializeWithProvider').mockResolvedValue({
+      const mockRuntime: LobeRuntimeAI = {
+        baseURL: 'abc',
+        chat: vi.fn(),
         models: vi.fn().mockRejectedValue(structuredError),
-      } as any);
+      };
+      vi.mocked(initModelRuntimeFromDB).mockResolvedValue(new ModelRuntime(mockRuntime));
 
       const response = await GET(request, { params: mockParams });
       const responseBody = await response.json();
@@ -128,9 +142,12 @@ describe('GET handler', () => {
         apiKey: 'test-api-key',
       });
 
-      vi.spyOn(ModelRuntime, 'initializeWithProvider').mockResolvedValue({
+      const mockRuntime: LobeRuntimeAI = {
+        baseURL: 'abc',
+        chat: vi.fn(),
         models: vi.fn().mockRejectedValue(new Error('Failed')),
-      } as any);
+      };
+      vi.mocked(initModelRuntimeFromDB).mockResolvedValue(new ModelRuntime(mockRuntime));
 
       const response = await GET(request, { params: mockParams });
 
@@ -144,9 +161,12 @@ describe('GET handler', () => {
         apiKey: 'test-api-key',
       });
 
-      vi.spyOn(ModelRuntime, 'initializeWithProvider').mockResolvedValue({
+      const mockRuntime: LobeRuntimeAI = {
+        baseURL: 'abc',
+        chat: vi.fn(),
         models: vi.fn().mockRejectedValue(new Error('Failed')),
-      } as any);
+      };
+      vi.mocked(initModelRuntimeFromDB).mockResolvedValue(new ModelRuntime(mockRuntime));
 
       const response = await GET(request, { params: mockParams });
       const responseBody = await response.json();
@@ -168,9 +188,12 @@ describe('GET handler', () => {
         { id: 'gpt-3.5-turbo', name: 'GPT-3.5 Turbo' },
       ];
 
-      vi.spyOn(ModelRuntime, 'initializeWithProvider').mockResolvedValue({
+      const mockRuntime: LobeRuntimeAI = {
+        baseURL: 'abc',
+        chat: vi.fn(),
         models: vi.fn().mockResolvedValue(mockModelList),
-      } as any);
+      };
+      vi.mocked(initModelRuntimeFromDB).mockResolvedValue(new ModelRuntime(mockRuntime));
 
       const response = await GET(request, { params: mockParams });
       const responseBody = await response.json();

package/src/app/(backend)/webapi/models/[provider]/route.ts

@@ -1,24 +1,17 @@
 import { type ChatCompletionErrorPayload } from '@lobechat/model-runtime';
 import { ChatErrorType } from '@lobechat/types';
-import { ModelProvider } from 'model-bank';
 import { NextResponse } from 'next/server';
 
 import { checkAuth } from '@/app/(backend)/middleware/auth';
-import { initModelRuntimeWithUserPayload } from '@/server/modules/ModelRuntime';
+import { initModelRuntimeFromDB } from '@/server/modules/ModelRuntime';
 import { createErrorResponse } from '@/utils/errorResponse';
 
-const noNeedAPIKey = (provider: string) => [ModelProvider.OpenRouter].includes(provider as any);
-
-export const GET = checkAuth(async (req, { params, jwtPayload }) => {
+export const GET = checkAuth(async (req, { params, userId, serverDB }) => {
   const provider = (await params)!.provider!;
 
   try {
-    const hasDefaultApiKey = jwtPayload.apiKey || 'dont-need-api-key-for-model-list';
-
-    const agentRuntime = await initModelRuntimeWithUserPayload(provider, {
-      ...jwtPayload,
-      apiKey: noNeedAPIKey(provider) ? hasDefaultApiKey : jwtPayload.apiKey,
-    });
+    // Read user's provider config from database
+    const agentRuntime = await initModelRuntimeFromDB(serverDB, userId, provider);
 
     const list = await agentRuntime.models();