@lobehub/chat 0.158.2 → 0.159.1

package/src/components/ModelTag/ModelIcon.tsx

@@ -9,6 +9,7 @@ import {
   Claude,
   Cohere,
   Dbrx,
+  DeepSeek,
   FishAudio,
   Gemini,
   Gemma,
@@ -43,6 +44,7 @@ const ModelIcon = memo<ModelIconProps>(({ model, size = 12 }) => {
   if (model.startsWith('gpt')) return <OpenAI size={size} />;
   if (model.startsWith('glm') || model.includes('chatglm')) return <ChatGLM size={size} />;
   if (model.includes('claude')) return <Claude size={size} />;
+  if (model.includes('deepseek')) return <DeepSeek size={size} />;
   if (model.includes('titan')) return <Aws size={size} />;
   if (model.includes('llama')) return <Meta size={size} />;
   if (model.includes('llava')) return <LLaVA size={size} />;

package/src/config/modelProviders/deepseek.ts

@@ -0,0 +1,23 @@
+import { ModelProviderCard } from '@/types/llm';
+
+const DeepSeek: ModelProviderCard = {
+  chatModels: [
+    {
+      description: '擅长通用对话任务',
+      displayName: 'DeepSeek-V2',
+      enabled: true,
+      id: 'deepseek-chat',
+      tokens: 32_768,
+    },
+    {
+      description: '擅长编程场景',
+      displayName: 'DeepSeek-coder',
+      enabled: true,
+      id: 'deepseek-coder',
+      tokens: 16_384,
+    },
+  ],
+  id: 'deepseek',
+};
+
+export default DeepSeek;

package/src/config/modelProviders/index.ts

@@ -3,6 +3,7 @@ import { ChatModelCard, ModelProviderCard } from '@/types/llm';
 import AnthropicProvider from './anthropic';
 import AzureProvider from './azure';
 import BedrockProvider from './bedrock';
+import DeepSeekProvider from './deepseek';
 import GoogleProvider from './google';
 import GroqProvider from './groq';
 import MinimaxProvider from './minimax';
@@ -20,6 +21,7 @@ export const LOBE_DEFAULT_MODEL_LIST: ChatModelCard[] = [
   OpenAIProvider.chatModels,
   ZhiPuProvider.chatModels,
   BedrockProvider.chatModels,
+  DeepSeekProvider.chatModels,
   GoogleProvider.chatModels,
   GroqProvider.chatModels,
   MinimaxProvider.chatModels,
@@ -38,6 +40,7 @@ export const DEFAULT_MODEL_PROVIDER_LIST = [
   { ...AzureProvider, chatModels: [] },
   OllamaProvider,
   AnthropicProvider,
+  DeepSeekProvider,
   GoogleProvider,
   OpenRouterProvider,
   TogetherAIProvider,
@@ -58,6 +61,7 @@ export const filterEnabledModels = (provider: ModelProviderCard) => {
 export { default as AnthropicProviderCard } from './anthropic';
 export { default as AzureProviderCard } from './azure';
 export { default as BedrockProviderCard } from './bedrock';
+export { default as DeepSeekProviderCard } from './deepseek';
 export { default as GoogleProviderCard } from './google';
 export { default as GroqProviderCard } from './groq';
 export { default as MinimaxProviderCard } from './minimax';

package/src/config/server/provider.ts

@@ -19,6 +19,10 @@ declare global {
       AZURE_ENDPOINT?: string;
       AZURE_API_VERSION?: string;
 
+      // DeepSeek Provider
+      ENABLED_DEEPSEEK?: string;
+      DEEPSEEK_API_KEY?: string;
+      
       // ZhiPu Provider
       ENABLED_ZHIPU?: string;
       ZHIPU_API_KEY?: string;
@@ -105,8 +109,11 @@ export const getProviderConfig = () => {
   const AZURE_API_KEY = process.env.AZURE_API_KEY || '';
 
   const ZHIPU_API_KEY = process.env.ZHIPU_API_KEY || '';
+
   const AWS_ACCESS_KEY_ID = process.env.AWS_ACCESS_KEY_ID || '';
 
+  const DEEPSEEK_API_KEY = process.env.DEEPSEEK_API_KEY || '';
+  
   const GOOGLE_API_KEY = process.env.GOOGLE_API_KEY || '';
 
   const MOONSHOT_API_KEY = process.env.MOONSHOT_API_KEY || '';
@@ -168,6 +175,9 @@ export const getProviderConfig = () => {
     ENABLED_ZHIPU: !!ZHIPU_API_KEY,
     ZHIPU_API_KEY,
 
+    ENABLED_DEEPSEEK: !!DEEPSEEK_API_KEY,
+    DEEPSEEK_API_KEY,
+
     ENABLED_GOOGLE: !!GOOGLE_API_KEY,
     GOOGLE_API_KEY,
     GOOGLE_PROXY_URL: process.env.GOOGLE_PROXY_URL,

package/src/const/settings/index.ts

@@ -1,6 +1,7 @@
 import {
   AnthropicProviderCard,
   BedrockProviderCard,
+  DeepSeekProviderCard,
   GoogleProviderCard,
   GroqProviderCard,
   MinimaxProviderCard,
@@ -81,6 +82,11 @@ export const DEFAULT_LLM_CONFIG: GlobalLLMConfig = {
     region: 'us-east-1',
     secretAccessKey: '',
   },
+  deepseek: {
+    apiKey: '',
+    enabled: false,
+    enabledModels: filterEnabledModels(DeepSeekProviderCard),
+  },
   google: {
     apiKey: '',
     enabled: false,

package/src/features/Conversation/Error/APIKeyForm/ProviderAvatar.tsx

@@ -1,5 +1,6 @@
 import {
   Anthropic,
+  DeepSeek,
   Google,
   Groq,
   Minimax,
@@ -53,6 +54,10 @@ const ProviderAvatar = memo<ProviderAvatarProps>(({ provider }) => {
       return <Anthropic color={Anthropic.colorPrimary} size={52} />;
     }
 
+    case ModelProvider.DeepSeek: {
+      return <DeepSeek color={DeepSeek.colorPrimary} size={56} />;
+    }
+
     case ModelProvider.Groq: {
       return <Groq color={Groq.colorPrimary} size={56} />;
     }

package/src/features/Conversation/Error/APIKeyForm/index.tsx

@@ -43,6 +43,10 @@ const APIKeyForm = memo<APIKeyFormProps>(({ id, provider }) => {
         return 'gsk_*****************************';
       }
 
+      case ModelProvider.DeepSeek: {
+        return 'sk_******************************';
+      }
+
       default: {
         return '*********************************';
       }

package/src/features/Conversation/Error/OAuthForm.tsx

@@ -1,20 +1,22 @@
 import { Icon } from '@lobehub/ui';
 import { App, Button } from 'antd';
 import { ScanFace } from 'lucide-react';
-import { signIn, signOut } from 'next-auth/react';
 import { memo, useCallback } from 'react';
 import { useTranslation } from 'react-i18next';
 import { Center, Flexbox } from 'react-layout-kit';
 
-import { useOAuthSession } from '@/hooks/useOAuthSession';
 import { useChatStore } from '@/store/chat';
+import { useUserStore } from '@/store/user';
+import { authSelectors, userProfileSelectors } from '@/store/user/selectors';
 
 import { FormAction } from './style';
 
 const OAuthForm = memo<{ id: string }>(({ id }) => {
   const { t } = useTranslation('error');
 
-  const { user, isOAuthLoggedIn } = useOAuthSession();
+  const [signIn, signOut] = useUserStore((s) => [s.openLogin, s.logout]);
+  const user = useUserStore(userProfileSelectors.userProfile);
+  const isOAuthLoggedIn = useUserStore(authSelectors.isLoginWithAuth);
 
   const [resend, deleteMessage] = useChatStore((s) => [s.regenerateMessage, s.deleteMessage]);
 
@@ -38,7 +40,7 @@ const OAuthForm = memo<{ id: string }>(({ id }) => {
         avatar={isOAuthLoggedIn ? '✅' : '🕵️‍♂️'}
         description={
           isOAuthLoggedIn
-            ? `${t('unlock.oauth.welcome')} ${user?.name}`
+            ? `${t('unlock.oauth.welcome')} ${user?.fullName || ''}`
             : t('unlock.oauth.description')
         }
         title={isOAuthLoggedIn ? t('unlock.oauth.success') : t('unlock.oauth.title')}

package/src/features/Conversation/Error/index.tsx

@@ -73,6 +73,7 @@ const ErrorMessageExtra = memo<{ data: ChatMessage }>(({ data }) => {
     }
 
     case AgentRuntimeErrorType.InvalidBedrockCredentials:
+    case AgentRuntimeErrorType.InvalidDeepSeekAPIKey:
     case AgentRuntimeErrorType.InvalidZhipuAPIKey:
     case AgentRuntimeErrorType.InvalidMinimaxAPIKey:
     case AgentRuntimeErrorType.InvalidMistralAPIKey:

package/src/features/User/__tests__/UserAvatar.test.tsx

@@ -30,6 +30,7 @@ describe('UserAvatar', () => {
 
       act(() => {
         useUserStore.setState({
+          enableAuth: () => true,
           isSignedIn: true,
           user: { avatar: mockAvatar, id: 'abc', username: mockUsername },
         });
@@ -45,7 +46,11 @@ describe('UserAvatar', () => {
       const mockUsername = 'testuser';
 
       act(() => {
-        useUserStore.setState({ isSignedIn: true, user: { id: 'bbb', username: mockUsername } });
+        useUserStore.setState({
+          enableAuth: () => true,
+          isSignedIn: true,
+          user: { id: 'bbb', username: mockUsername },
+        });
       });
 
       render(<UserAvatar />);
@@ -54,7 +59,7 @@ describe('UserAvatar', () => {
 
     it('should show LobeChat and default avatar when the user is not logged in and enable auth', () => {
       act(() => {
-        useUserStore.setState({ isSignedIn: false, user: undefined });
+        useUserStore.setState({ enableAuth: () => true, isSignedIn: false, user: undefined });
       });
 
       render(<UserAvatar />);
@@ -67,7 +72,7 @@ describe('UserAvatar', () => {
     it('should show LobeChat and default avatar when the user is not logged in and disabled auth', () => {
       enableAuth = false;
       act(() => {
-        useUserStore.setState({ isSignedIn: false, user: undefined });
+        useUserStore.setState({ enableAuth: () => false, isSignedIn: false, user: undefined });
       });
 
       render(<UserAvatar />);

package/src/features/User/__tests__/useMenu.test.tsx

@@ -64,7 +64,7 @@ afterEach(() => {
 describe('useMenu', () => {
   it('should provide correct menu items when user is logged in with auth', () => {
     act(() => {
-      useUserStore.setState({ isSignedIn: true });
+      useUserStore.setState({ isSignedIn: true, enableAuth: () => true });
     });
     enableAuth = true;
     enableClerk = false;
@@ -104,7 +104,7 @@ describe('useMenu', () => {
 
   it('should provide correct menu items when user is logged in without auth', () => {
     act(() => {
-      useUserStore.setState({ isSignedIn: false });
+      useUserStore.setState({ isSignedIn: false, enableAuth: () => false });
     });
     enableAuth = false;
 
@@ -123,7 +123,7 @@ describe('useMenu', () => {
 
   it('should provide correct menu items when user is not logged in', () => {
     act(() => {
-      useUserStore.setState({ isSignedIn: false });
+      useUserStore.setState({ isSignedIn: false, enableAuth: () => true });
     });
     enableAuth = true;
 

package/src/libs/agent-runtime/AgentRuntime.ts

@@ -6,6 +6,7 @@ import { LobeRuntimeAI } from './BaseAI';
 import { LobeAnthropicAI } from './anthropic';
 import { LobeAzureOpenAI } from './azureOpenai';
 import { LobeBedrockAI, LobeBedrockAIParams } from './bedrock';
+import { LobeDeepSeekAI } from './deepseek';
 import { LobeGoogleAI } from './google';
 import { LobeGroq } from './groq';
 import { LobeMinimaxAI } from './minimax';
@@ -101,6 +102,7 @@ class AgentRuntime {
       anthropic: Partial<ClientOptions>;
       azure: { apiVersion?: string; apikey?: string; endpoint?: string };
       bedrock: Partial<LobeBedrockAIParams>;
+      deepseek: Partial<ClientOptions>;
       google: { apiKey?: string; baseURL?: string };
       groq: Partial<ClientOptions>;
       minimax: Partial<ClientOptions>;
@@ -169,6 +171,11 @@ class AgentRuntime {
         break;
       }
 
+      case ModelProvider.DeepSeek: {
+        runtimeModel = new LobeDeepSeekAI(params.deepseek ?? {});
+        break;
+      }
+      
       case ModelProvider.Minimax: {
         runtimeModel = new LobeMinimaxAI(params.minimax ?? {});
         break;

package/src/libs/agent-runtime/deepseek/index.test.ts

@@ -0,0 +1,254 @@
+// @vitest-environment node
+import OpenAI from 'openai';
+import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  ChatStreamCallbacks,
+  LobeOpenAICompatibleRuntime,
+  ModelProvider,
+} from '@/libs/agent-runtime';
+
+import * as debugStreamModule from '../utils/debugStream';
+import { LobeDeepSeekAI } from './index';
+
+const provider = ModelProvider.DeepSeek;
+const defaultBaseURL = 'https://api.deepseek.com/v1';
+const bizErrorType = 'DeepSeekBizError';
+const invalidErrorType = 'InvalidDeepSeekAPIKey';
+
+// Mock the console.error to avoid polluting test output
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+let instance: LobeOpenAICompatibleRuntime;
+
+beforeEach(() => {
+  instance = new LobeDeepSeekAI({ apiKey: 'test' });
+
+  // 使用 vi.spyOn 来模拟 chat.completions.create 方法
+  vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+    new ReadableStream() as any,
+  );
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('LobeDeepSeekAI', () => {
+  describe('init', () => {
+    it('should correctly initialize with an API key', async () => {
+      const instance = new LobeDeepSeekAI({ apiKey: 'test_api_key' });
+      expect(instance).toBeInstanceOf(LobeDeepSeekAI);
+      expect(instance.baseURL).toEqual(defaultBaseURL);
+    });
+  });
+
+  describe('chat', () => {
+    describe('Error', () => {
+      it('should return OpenAIBizError with an openai error response when OpenAI.APIError is thrown', async () => {
+        // Arrange
+        const apiError = new OpenAI.APIError(
+          400,
+          {
+            status: 400,
+            error: {
+              message: 'Bad Request',
+            },
+          },
+          'Error message',
+          {},
+        );
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+
+        // Act
+        try {
+          await instance.chat({
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: 'deepseek-chat',
+            temperature: 0,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: defaultBaseURL,
+            error: {
+              error: { message: 'Bad Request' },
+              status: 400,
+            },
+            errorType: bizErrorType,
+            provider,
+          });
+        }
+      });
+
+      it('should throw AgentRuntimeError with NoOpenAIAPIKey if no apiKey is provided', async () => {
+        try {
+          new LobeDeepSeekAI({});
+        } catch (e) {
+          expect(e).toEqual({ errorType: invalidErrorType });
+        }
+      });
+
+      it('should return OpenAIBizError with the cause when OpenAI.APIError is thrown with cause', async () => {
+        // Arrange
+        const errorInfo = {
+          stack: 'abc',
+          cause: {
+            message: 'api is undefined',
+          },
+        };
+        const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+
+        // Act
+        try {
+          await instance.chat({
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: 'deepseek-chat',
+            temperature: 0,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: defaultBaseURL,
+            error: {
+              cause: { message: 'api is undefined' },
+              stack: 'abc',
+            },
+            errorType: bizErrorType,
+            provider,
+          });
+        }
+      });
+
+      it('should return OpenAIBizError with an cause response with desensitize Url', async () => {
+        // Arrange
+        const errorInfo = {
+          stack: 'abc',
+          cause: { message: 'api is undefined' },
+        };
+        const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
+
+        instance = new LobeDeepSeekAI({
+          apiKey: 'test',
+
+          baseURL: 'https://api.abc.com/v1',
+        });
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+
+        // Act
+        try {
+          await instance.chat({
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: 'deepseek-chat',
+            temperature: 0,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: 'https://api.***.com/v1',
+            error: {
+              cause: { message: 'api is undefined' },
+              stack: 'abc',
+            },
+            errorType: bizErrorType,
+            provider,
+          });
+        }
+      });
+
+      it('should throw an InvalidDeepSeekAPIKey error type on 401 status code', async () => {
+        // Mock the API call to simulate a 401 error
+        const error = new Error('Unauthorized') as any;
+        error.status = 401;
+        vi.mocked(instance['client'].chat.completions.create).mockRejectedValue(error);
+
+        try {
+          await instance.chat({
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: 'deepseek-chat',
+            temperature: 0,
+          });
+        } catch (e) {
+          // Expect the chat method to throw an error with InvalidDeepSeekAPIKey
+          expect(e).toEqual({
+            endpoint: defaultBaseURL,
+            error: new Error('Unauthorized'),
+            errorType: invalidErrorType,
+            provider,
+          });
+        }
+      });
+
+      it('should return AgentRuntimeError for non-OpenAI errors', async () => {
+        // Arrange
+        const genericError = new Error('Generic Error');
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(genericError);
+
+        // Act
+        try {
+          await instance.chat({
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: 'deepseek-chat',
+            temperature: 0,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: defaultBaseURL,
+            errorType: 'AgentRuntimeError',
+            provider,
+            error: {
+              name: genericError.name,
+              cause: genericError.cause,
+              message: genericError.message,
+              stack: genericError.stack,
+            },
+          });
+        }
+      });
+    });
+
+    describe('DEBUG', () => {
+      it('should call debugStream and return StreamingTextResponse when DEBUG_DEEPSEEK_CHAT_COMPLETION is 1', async () => {
+        // Arrange
+        const mockProdStream = new ReadableStream() as any; // 模拟的 prod 流
+        const mockDebugStream = new ReadableStream({
+          start(controller) {
+            controller.enqueue('Debug stream content');
+            controller.close();
+          },
+        }) as any;
+        mockDebugStream.toReadableStream = () => mockDebugStream; // 添加 toReadableStream 方法
+
+        // 模拟 chat.completions.create 返回值，包括模拟的 tee 方法
+        (instance['client'].chat.completions.create as Mock).mockResolvedValue({
+          tee: () => [mockProdStream, { toReadableStream: () => mockDebugStream }],
+        });
+
+        // 保存原始环境变量值
+        const originalDebugValue = process.env.DEBUG_DEEPSEEK_CHAT_COMPLETION;
+
+        // 模拟环境变量
+        process.env.DEBUG_DEEPSEEK_CHAT_COMPLETION = '1';
+        vi.spyOn(debugStreamModule, 'debugStream').mockImplementation(() => Promise.resolve());
+
+        // 执行测试
+        // 运行你的测试函数，确保它会在条件满足时调用 debugStream
+        // 假设的测试函数调用，你可能需要根据实际情况调整
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'deepseek-chat',
+          stream: true,
+          temperature: 0,
+        });
+
+        // 验证 debugStream 被调用
+        expect(debugStreamModule.debugStream).toHaveBeenCalled();
+
+        // 恢复原始环境变量值
+        process.env.DEBUG_DEEPSEEK_CHAT_COMPLETION = originalDebugValue;
+      });
+    });
+  });
+});

package/src/libs/agent-runtime/deepseek/index.ts

@@ -0,0 +1,15 @@
+import { AgentRuntimeErrorType } from '../error';
+import { ModelProvider } from '../types';
+import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
+
+export const LobeDeepSeekAI = LobeOpenAICompatibleFactory({
+  baseURL: 'https://api.deepseek.com/v1',
+  debug: {
+    chatCompletion: () => process.env.DEBUG_DEEPSEEK_CHAT_COMPLETION === '1',
+  },
+  errorType: {
+    bizError: AgentRuntimeErrorType.DeepSeekBizError,
+    invalidAPIKey: AgentRuntimeErrorType.InvalidDeepSeekAPIKey,
+  },
+  provider: ModelProvider.DeepSeek,
+});

package/src/libs/agent-runtime/error.ts

@@ -49,6 +49,9 @@ export const AgentRuntimeErrorType = {
 
   InvalidMinimaxAPIKey: 'InvalidMinimaxAPIKey',
   MinimaxBizError: 'MinimaxBizError',
+
+  InvalidDeepSeekAPIKey: 'InvalidDeepSeekAPIKey',
+  DeepSeekBizError: 'DeepSeekBizError',
 } as const;
 
 export type ILobeAgentRuntimeErrorType =

package/src/libs/agent-runtime/index.ts

@@ -3,6 +3,7 @@ export { LobeAnthropicAI } from './anthropic';
 export { LobeAzureOpenAI } from './azureOpenai';
 export * from './BaseAI';
 export { LobeBedrockAI } from './bedrock';
+export { LobeDeepSeekAI } from './deepseek';
 export * from './error';
 export { LobeGoogleAI } from './google';
 export { LobeGroq } from './groq';

package/src/libs/agent-runtime/types/type.ts

@@ -26,6 +26,7 @@ export enum ModelProvider {
   Azure = 'azure',
   Bedrock = 'bedrock',
   ChatGLM = 'chatglm',
+  DeepSeek = 'deepseek',
   Google = 'google',
   Groq = 'groq',
   Minimax = 'minimax',

package/src/libs/next-auth/index.ts

@@ -44,10 +44,3 @@ export const {
   handlers: { GET, POST },
   auth,
 } = nextAuth;
-
-declare module '@auth/core/jwt' {
-  // Returned by the `jwt` callback and `auth`, when using JWT sessions
-  interface JWT {
-    userId?: string;
-  }
-}

package/src/locales/default/error.ts

@@ -92,6 +92,9 @@ export default {
     InvalidBedrockCredentials: 'Bedrock 鉴权未通过，请检查 AccessKeyId/SecretAccessKey 后重试',
     BedrockBizError: '请求 Bedrock 服务出错，请根据以下信息排查或重试',
 
+    InvalidDeepSeekAPIKey: 'DeepSeek API Key 不正确或为空，请检查 DeepSeek API Key 后重试',
+    DeepSeekBizError: '请求 DeepSeek 服务出错，请根据以下信息排查或重试',
+    
     InvalidAzureAPIKey: 'Azure API Key 不正确或为空，请检查 Azure API Key 后重试',
     AzureBizError: '请求 Azure AI 服务出错，请根据以下信息排查或重试',
 

package/src/locales/default/modelProvider.ts

@@ -62,6 +62,18 @@ export default {
       title: '使用自定义 Bedrock 鉴权信息',
     },
   },
+  deepseek: {
+    title: 'DeepSeek',
+    token: {
+      desc: '填入来自 DeepSeek 的 API Key',
+      placeholder: 'DeepSeek API Key',
+      title: 'API Key',
+    },
+    unlock: {
+      description: '输入你的 DeepSeek API Key 即可开始会话。应用不会记录你的 API Key',
+      title: '使用自定义 DeepSeek API Key',
+    },
+  },
   google: {
     title: 'Google',
     token: {

package/src/migrations/FromV3ToV4/types/v3.ts

@@ -22,20 +22,12 @@ export interface V3LegacyConfig {
 }
 
 export interface V3LLMConfig {
-  anthropic: V3GeneralConfig;
   bedrock: any;
   google: V3GeneralConfig;
-  groq: V3GeneralConfig;
-  minimax: V3GeneralConfig;
-  mistral: V3GeneralConfig;
-  moonshot: V3GeneralConfig;
   ollama: V3LegacyConfig;
   openAI: V3OpenAIConfig;
   openrouter: V3LegacyConfig;
-  perplexity: V3GeneralConfig;
   togetherai: V3LegacyConfig;
-  zeroone: V3GeneralConfig;
-  zhipu: V3GeneralConfig;
 }
 
 /**