@lobehub/chat 1.20.8 → 1.21.1

package/scripts/serverLauncher/startServer.js

@@ -1,6 +1,5 @@
 const dns = require('dns').promises;
 const fs = require('fs').promises;
-const tls = require('tls');
 const { spawn } = require('child_process');
 
 // Set file paths
@@ -23,68 +22,6 @@ const isValidIP = (ip, version = 4) => {
   }
 };
 
-// Function to check TLS validity of a URL
-const isValidTLS = (url = '') => {
-  if (!url) {
-    console.log('⚠️ TLS Check: No URL provided. Skipping TLS check. Ensure correct setting ENV.');
-    console.log('-------------------------------------');
-    return Promise.resolve();
-  }
-
-  const { protocol, host, port } = parseUrl(url);
-  if (protocol !== 'https') {
-    console.log(`⚠️ TLS Check: Non-HTTPS protocol (${protocol}). Skipping TLS check for ${url}.`);
-    console.log('-------------------------------------');
-    return Promise.resolve();
-  }
-
-  const options = { host, port, servername: host };
-  return new Promise((resolve, reject) => {
-    const socket = tls.connect(options, () => {
-      console.log(`✅ TLS Check: Valid certificate for ${host}:${port}.`);
-      console.log('-------------------------------------');
-
-      socket.end();
-
-      resolve();
-    });
-
-    socket.on('error', (err) => {
-      const errMsg = `❌ TLS Check: Error for ${host}:${port}. Details:`;
-      switch (err.code) {
-        case 'CERT_HAS_EXPIRED':
-        case 'DEPTH_ZERO_SELF_SIGNED_CERT':
-        case 'ERR_TLS_CERT_ALTNAME_INVALID':
-          console.error(`${errMsg} Certificate is not valid. Consider setting NODE_TLS_REJECT_UNAUTHORIZED="0" or mapping /etc/ssl/certs/ca-certificates.crt.`);
-          break;
-        case 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY':
-          console.error(`${errMsg} Unable to verify issuer. Ensure correct mapping of /etc/ssl/certs/ca-certificates.crt.`);
-          break;
-        default:
-          console.error(`${errMsg} Network issue. Check firewall or DNS.`);
-          break;
-      }
-      reject(err);
-    });
-  });
-};
-
-// Function to check TLS connections for OSS and Auth Issuer
-const checkTLSConnections = async () => {
-  await Promise.all([
-    isValidTLS(process.env.S3_ENDPOINT),
-    isValidTLS(process.env.S3_PUBLIC_DOMAIN),
-    isValidTLS(getEnvVarsByKeyword('_ISSUER')),
-  ]);
-};
-
-// Function to get environment variable by keyword
-const getEnvVarsByKeyword = (keyword) => {
-  return Object.entries(process.env)
-    .filter(([key, value]) => key.includes(keyword) && value)
-    .map(([, value]) => value)[0] || null;
-};
-
 // Function to parse protocol, host and port from a URL
 const parseUrl = (url) => {
   const { protocol, hostname: host, port } = new URL(url);
@@ -170,26 +107,18 @@ const runServer = async () => {
 
   if (process.env.DATABASE_DRIVER) {
     try {
-      try {
-        await fs.access(DB_MIGRATION_SCRIPT_PATH);
-
-        await runScript(DB_MIGRATION_SCRIPT_PATH);
-      } catch (err) {
-        if (err.code === 'ENOENT') {
-          console.log(`⚠️ DB Migration: Not found ${DB_MIGRATION_SCRIPT_PATH}. Skipping DB migration. Ensure to migrate database manually.`);
-          console.log('-------------------------------------');
-        } else {
-          console.error('❌ Error during DB migration:');
-          console.error(err);
-          process.exit(1);
-        }
-      }
+      await fs.access(DB_MIGRATION_SCRIPT_PATH);
 
-      await checkTLSConnections();
+      await runScript(DB_MIGRATION_SCRIPT_PATH);
     } catch (err) {
-      console.error('❌ Error during TLS connection check:');
-      console.error(err);
-      process.exit(1);
+      if (err.code === 'ENOENT') {
+        console.log(`⚠️ DB Migration: Not found ${DB_MIGRATION_SCRIPT_PATH}. Skipping DB migration. Ensure to migrate database manually.`);
+        console.log('-------------------------------------');
+      } else {
+        console.error('❌ Error during DB migration:');
+        console.error(err);
+        process.exit(1);
+      }
     }
   }
 

package/src/app/(main)/settings/llm/ProviderList/Wenxin/index.tsx

@@ -0,0 +1,46 @@
+'use client';
+
+import { Wenxin } from '@lobehub/icons';
+import { Input } from 'antd';
+import { useTranslation } from 'react-i18next';
+
+import { WenxinProviderCard } from '@/config/modelProviders';
+import { GlobalLLMProviderKey } from '@/types/user/settings';
+
+import { KeyVaultsConfigKey } from '../../const';
+import { ProviderItem } from '../../type';
+
+const providerKey: GlobalLLMProviderKey = 'wenxin';
+
+export const useWenxinProvider = (): ProviderItem => {
+  const { t } = useTranslation('modelProvider');
+
+  return {
+    ...WenxinProviderCard,
+    apiKeyItems: [
+      {
+        children: (
+          <Input.Password
+            autoComplete={'new-password'}
+            placeholder={t(`${providerKey}.accessKey.placeholder`)}
+          />
+        ),
+        desc: t(`${providerKey}.accessKey.desc`),
+        label: t(`${providerKey}.accessKey.title`),
+        name: [KeyVaultsConfigKey, providerKey, 'accessKey'],
+      },
+      {
+        children: (
+          <Input.Password
+            autoComplete={'new-password'}
+            placeholder={t(`${providerKey}.secretKey.placeholder`)}
+          />
+        ),
+        desc: t(`${providerKey}.secretKey.desc`),
+        label: t(`${providerKey}.secretKey.title`),
+        name: [KeyVaultsConfigKey, providerKey, 'secretKey'],
+      },
+    ],
+    title: <Wenxin.Combine size={32} type={'color'} />,
+  };
+};

package/src/app/(main)/settings/llm/ProviderList/providers.tsx

@@ -33,6 +33,7 @@ import { useBedrockProvider } from './Bedrock';
 import { useGithubProvider } from './Github';
 import { useOllamaProvider } from './Ollama';
 import { useOpenAIProvider } from './OpenAI';
+import { useWenxinProvider } from './Wenxin';
 
 export const useProviderList = (): ProviderItem[] => {
   const AzureProvider = useAzureProvider();
@@ -40,6 +41,7 @@ export const useProviderList = (): ProviderItem[] => {
   const OpenAIProvider = useOpenAIProvider();
   const BedrockProvider = useBedrockProvider();
   const GithubProvider = useGithubProvider();
+  const WenxinProvider = useWenxinProvider();
 
   return useMemo(
     () => [
@@ -61,6 +63,7 @@ export const useProviderList = (): ProviderItem[] => {
       Ai21ProviderCard,
       UpstageProviderCard,
       QwenProviderCard,
+      WenxinProvider,
       HunyuanProviderCard,
       SparkProviderCard,
       ZhiPuProviderCard,
@@ -73,6 +76,6 @@ export const useProviderList = (): ProviderItem[] => {
       TaichuProviderCard,
       SiliconCloudProviderCard,
     ],
-    [AzureProvider, OllamaProvider, OpenAIProvider, BedrockProvider, GithubProvider],
+    [AzureProvider, OllamaProvider, OpenAIProvider, BedrockProvider, GithubProvider,WenxinProvider],
   );
 };

package/src/app/api/chat/agentRuntime.test.ts

@@ -25,6 +25,7 @@ import {
 } from '@/libs/agent-runtime';
 import { AgentRuntime } from '@/libs/agent-runtime';
 import { LobeStepfunAI } from '@/libs/agent-runtime/stepfun';
+import LobeWenxinAI from '@/libs/agent-runtime/wenxin';
 
 import { initAgentRuntimeWithUserPayload } from './agentRuntime';
 
@@ -54,6 +55,9 @@ vi.mock('@/config/llm', () => ({
     TOGETHERAI_API_KEY: 'test-togetherai-key',
     QWEN_API_KEY: 'test-qwen-key',
     STEPFUN_API_KEY: 'test-stepfun-key',
+
+    WENXIN_ACCESS_KEY: 'test-wenxin-access-key',
+    WENXIN_SECRET_KEY: 'test-wenxin-secret-key',
   })),
 }));
 
@@ -202,6 +206,16 @@ describe('initAgentRuntimeWithUserPayload method', () => {
       expect(runtime['_runtime']).toBeInstanceOf(LobeStepfunAI);
     });
 
+    it.skip('Wenxin AI provider: with apikey', async () => {
+      const jwtPayload: JWTPayload = {
+        wenxinAccessKey: 'user-wenxin-accessKey',
+        wenxinSecretKey: 'wenxin-secret-key',
+      };
+      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Wenxin, jwtPayload);
+      expect(runtime).toBeInstanceOf(AgentRuntime);
+      expect(runtime['_runtime']).toBeInstanceOf(LobeWenxinAI);
+    });
+
     it('Unknown Provider: with apikey and endpoint, should initialize to OpenAi', async () => {
       const jwtPayload: JWTPayload = {
         apiKey: 'user-unknown-key',
@@ -339,6 +353,13 @@ describe('initAgentRuntimeWithUserPayload method', () => {
       expect(runtime['_runtime']).toBeInstanceOf(LobeTogetherAI);
     });
 
+    it.skip('Wenxin AI provider: without apikey', async () => {
+      const jwtPayload = {};
+      const runtime = await initAgentRuntimeWithUserPayload(ModelProvider.Wenxin, jwtPayload);
+      expect(runtime).toBeInstanceOf(AgentRuntime);
+      expect(runtime['_runtime']).toBeInstanceOf(LobeWenxinAI);
+    });
+
     it('Unknown Provider', async () => {
       const jwtPayload = {};
       const runtime = await initAgentRuntimeWithUserPayload('unknown', jwtPayload);

package/src/app/api/chat/wenxin/route.test.ts

@@ -0,0 +1,27 @@
+// @vitest-environment edge-runtime
+import { describe, expect, it, vi } from 'vitest';
+
+import { POST as UniverseRoute } from '../[provider]/route';
+import { POST, runtime } from './route';
+
+// 模拟 '../[provider]/route'
+vi.mock('../[provider]/route', () => ({
+  POST: vi.fn().mockResolvedValue('mocked response'),
+}));
+
+describe('Configuration tests', () => {
+  it('should have runtime set to "edge"', () => {
+    expect(runtime).toBe('nodejs');
+  });
+});
+
+describe('Wenxin POST function tests', () => {
+  it('should call UniverseRoute with correct parameters', async () => {
+    const mockRequest = new Request('https://example.com', { method: 'POST' });
+    await POST(mockRequest);
+    expect(UniverseRoute).toHaveBeenCalledWith(mockRequest, {
+      createRuntime: expect.anything(),
+      params: { provider: 'wenxin' },
+    });
+  });
+});

package/src/app/api/chat/wenxin/route.ts

@@ -0,0 +1,30 @@
+import { getLLMConfig } from '@/config/llm';
+import { AgentRuntime } from '@/libs/agent-runtime';
+import LobeWenxinAI from '@/libs/agent-runtime/wenxin';
+
+import { POST as UniverseRoute } from '../[provider]/route';
+
+export const runtime = 'nodejs';
+
+export const maxDuration = 30;
+
+export const POST = async (req: Request) =>
+  UniverseRoute(req, {
+    createRuntime: (payload) => {
+      const { WENXIN_ACCESS_KEY, WENXIN_SECRET_KEY } = getLLMConfig();
+      let accessKey: string | undefined = WENXIN_ACCESS_KEY;
+      let secretKey: string | undefined = WENXIN_SECRET_KEY;
+
+      // if the payload has the api key, use user
+      if (payload.apiKey) {
+        accessKey = payload?.wenxinAccessKey;
+        secretKey = payload?.wenxinSecretKey;
+      }
+
+      const params = { accessKey, secretKey };
+      const instance = new LobeWenxinAI(params);
+
+      return new AgentRuntime(instance);
+    },
+    params: { provider: 'wenxin' },
+  });

package/src/app/api/errorResponse.ts

@@ -16,6 +16,10 @@ const getStatus = (errorType: ILobeAgentRuntimeErrorType | ErrorType) => {
       return 403;
     }
 
+    case AgentRuntimeErrorType.QuotaLimitReached: {
+      return 429;
+    }
+
     // define the 471~480 as provider error
     case AgentRuntimeErrorType.AgentRuntimeError: {
       return 470;

package/src/config/llm.ts

@@ -80,6 +80,10 @@ export const getLLMConfig = () => {
       AWS_SECRET_ACCESS_KEY: z.string().optional(),
       AWS_SESSION_TOKEN: z.string().optional(),
 
+      ENABLED_WENXIN: z.boolean(),
+      WENXIN_ACCESS_KEY: z.string().optional(),
+      WENXIN_SECRET_KEY: z.string().optional(),
+
       ENABLED_OLLAMA: z.boolean(),
       OLLAMA_PROXY_URL: z.string().optional(),
       OLLAMA_MODEL_LIST: z.string().optional(),
@@ -198,6 +202,10 @@ export const getLLMConfig = () => {
       AWS_SECRET_ACCESS_KEY: process.env.AWS_SECRET_ACCESS_KEY,
       AWS_SESSION_TOKEN: process.env.AWS_SESSION_TOKEN,
 
+      ENABLED_WENXIN: !!process.env.WENXIN_ACCESS_KEY && !!process.env.WENXIN_SECRET_KEY,
+      WENXIN_ACCESS_KEY: process.env.WENXIN_ACCESS_KEY,
+      WENXIN_SECRET_KEY: process.env.WENXIN_SECRET_KEY,
+
       ENABLED_OLLAMA: process.env.ENABLED_OLLAMA !== '0',
       OLLAMA_PROXY_URL: process.env.OLLAMA_PROXY_URL || '',
       OLLAMA_MODEL_LIST: process.env.OLLAMA_MODEL_LIST,

package/src/config/modelProviders/index.ts

@@ -27,6 +27,7 @@ import StepfunProvider from './stepfun';
 import TaichuProvider from './taichu';
 import TogetherAIProvider from './togetherai';
 import UpstageProvider from './upstage';
+import WenxinProvider from './wenxin';
 import ZeroOneProvider from './zeroone';
 import ZhiPuProvider from './zhipu';
 
@@ -59,6 +60,7 @@ export const LOBE_DEFAULT_MODEL_LIST: ChatModelCard[] = [
   SparkProvider.chatModels,
   Ai21Provider.chatModels,
   HunyuanProvider.chatModels,
+  WenxinProvider.chatModels,
 ].flat();
 
 export const DEFAULT_MODEL_PROVIDER_LIST = [
@@ -80,6 +82,7 @@ export const DEFAULT_MODEL_PROVIDER_LIST = [
   Ai21Provider,
   UpstageProvider,
   QwenProvider,
+  WenxinProvider,
   HunyuanProvider,
   SparkProvider,
   ZhiPuProvider,
@@ -129,5 +132,6 @@ export { default as StepfunProviderCard } from './stepfun';
 export { default as TaichuProviderCard } from './taichu';
 export { default as TogetherAIProviderCard } from './togetherai';
 export { default as UpstageProviderCard } from './upstage';
+export { default as WenxinProviderCard } from './wenxin';
 export { default as ZeroOneProviderCard } from './zeroone';
 export { default as ZhiPuProviderCard } from './zhipu';

package/src/config/modelProviders/wenxin.ts

@@ -0,0 +1,159 @@
+import { ModelProviderCard } from '@/types/llm';
+
+// ref https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Nlks5zkzu
+const BaiduWenxin: ModelProviderCard = {
+  chatModels: [
+    {
+      description:
+        '百度自研的旗舰级大规模⼤语⾔模型，覆盖海量中英文语料，具有强大的通用能力，可满足绝大部分对话问答、创作生成、插件应用场景要求；支持自动对接百度搜索插件，保障问答信息时效。',
+      displayName: 'ERNIE 3.5 8K',
+      enabled: true,
+      id: 'ERNIE-3.5-8K',
+      pricing: {
+        currency: 'CNY',
+        input: 0.8,
+        output: 2,
+      },
+      tokens: 8192,
+    },
+    {
+      description:
+        '百度自研的旗舰级大规模⼤语⾔模型，覆盖海量中英文语料，具有强大的通用能力，可满足绝大部分对话问答、创作生成、插件应用场景要求；支持自动对接百度搜索插件，保障问答信息时效。',
+      displayName: 'ERNIE 3.5 8K Preview',
+      id: 'ERNIE-3.5-8K-Preview',
+      pricing: {
+        currency: 'CNY',
+        input: 0.8,
+        output: 2,
+      },
+      tokens: 8192,
+    },
+    {
+      description:
+        '百度自研的旗舰级大规模⼤语⾔模型，覆盖海量中英文语料，具有强大的通用能力，可满足绝大部分对话问答、创作生成、插件应用场景要求；支持自动对接百度搜索插件，保障问答信息时效。',
+      displayName: 'ERNIE 3.5 128K',
+      enabled: true,
+      id: 'ERNIE-3.5-128K',
+      pricing: {
+        currency: 'CNY',
+        input: 0.8,
+        output: 2,
+      },
+      tokens: 128_000,
+    },
+    {
+      description:
+        '百度自研的旗舰级超大规模⼤语⾔模型，相较ERNIE 3.5实现了模型能力全面升级，广泛适用于各领域复杂任务场景；支持自动对接百度搜索插件，保障问答信息时效。',
+      displayName: 'ERNIE 4.0 8K',
+      enabled: true,
+      id: 'ERNIE-4.0-8K-Latest',
+      pricing: {
+        currency: 'CNY',
+        input: 30,
+        output: 90,
+      },
+      tokens: 8192,
+    },
+    {
+      description:
+        '百度自研的旗舰级超大规模⼤语⾔模型，相较ERNIE 3.5实现了模型能力全面升级，广泛适用于各领域复杂任务场景；支持自动对接百度搜索插件，保障问答信息时效。',
+      displayName: 'ERNIE 4.0 8K Preview',
+      id: 'ERNIE-4.0-8K-Preview',
+      pricing: {
+        currency: 'CNY',
+        input: 30,
+        output: 90,
+      },
+      tokens: 8192,
+    },
+    {
+      description:
+        '百度自研的旗舰级超大规模⼤语⾔模型，综合效果表现出色，广泛适用于各领域复杂任务场景；支持自动对接百度搜索插件，保障问答信息时效。相较于ERNIE 4.0在性能表现上更优秀',
+      displayName: 'ERNIE 4.0 Turbo 8K',
+      enabled: true,
+      id: 'ERNIE-4.0-Turbo-8K',
+      pricing: {
+        currency: 'CNY',
+        input: 20,
+        output: 60,
+      },
+      tokens: 8192,
+    },
+    {
+      description:
+        '百度自研的旗舰级超大规模⼤语⾔模型，综合效果表现出色，广泛适用于各领域复杂任务场景；支持自动对接百度搜索插件，保障问答信息时效。相较于ERNIE 4.0在性能表现上更优秀',
+      displayName: 'ERNIE 4.0 Turbo 8K Preview',
+      id: 'ERNIE-4.0-Turbo-8K-Preview',
+      pricing: {
+        currency: 'CNY',
+        input: 20,
+        output: 60,
+      },
+      tokens: 8192,
+    },
+    {
+      description:
+        '百度自研的轻量级大语言模型，兼顾优异的模型效果与推理性能，效果比ERNIE Lite更优，适合低算力AI加速卡推理使用。',
+      displayName: 'ERNIE Lite Pro 128K',
+      enabled: true,
+      id: 'ERNIE-Lite-Pro-128K',
+      pricing: {
+        currency: 'CNY',
+        input: 0.2,
+        output: 0.4,
+      },
+      tokens: 128_000,
+    },
+    {
+      description:
+        '百度2024年最新发布的自研高性能大语言模型，通用能力优异，效果比ERNIE Speed更优，适合作为基座模型进行精调，更好地处理特定场景问题，同时具备极佳的推理性能。',
+      displayName: 'ERNIE Speed Pro 128K',
+      enabled: true,
+      id: 'ERNIE-Speed-Pro-128K',
+      pricing: {
+        currency: 'CNY',
+        input: 0.3,
+        output: 0.6,
+      },
+      tokens: 128_000,
+    },
+    {
+      description:
+        '百度2024年最新发布的自研高性能大语言模型，通用能力优异，适合作为基座模型进行精调，更好地处理特定场景问题，同时具备极佳的推理性能。',
+      displayName: 'ERNIE Speed 128K',
+      id: 'ERNIE-Speed-128K',
+      pricing: {
+        currency: 'CNY',
+        input: 0,
+        output: 0,
+      },
+      tokens: 128_000,
+    },
+    {
+      description:
+        '百度自研的垂直场景大语言模型，适合游戏NPC、客服对话、对话角色扮演等应用场景，人设风格更为鲜明、一致，指令遵循能力更强，推理性能更优。',
+      displayName: 'ERNIE Character 8K',
+      id: 'ERNIE-Character-8K',
+      pricing: {
+        currency: 'CNY',
+        input: 4,
+        output: 8,
+      },
+      tokens: 8192,
+    },
+  ],
+  checkModel: 'ERNIE-Speed-128K',
+  description:
+    '企业级一站式大模型与AI原生应用开发及服务平台，提供最全面易用的生成式人工智能模型开发、应用开发全流程工具链',
+  disableBrowserRequest: true,
+  id: 'wenxin',
+  modelsUrl: 'https://cloud.baidu.com/doc/WENXINWORKSHOP/s/Nlks5zkzu#%E5%AF%B9%E8%AF%9Dchat',
+  name: 'Wenxin',
+  smoothing: {
+    speed: 2,
+    text: true,
+  },
+  url: 'https://cloud.baidu.com/wenxin.html',
+};
+
+export default BaiduWenxin;

package/src/const/auth.ts

@@ -36,6 +36,10 @@ export interface JWTPayload {
   awsRegion?: string;
   awsSecretAccessKey?: string;
   awsSessionToken?: string;
+
+  wenxinAccessKey?: string;
+  wenxinSecretKey?: string;
+
   /**
    * user id
    * in client db mode it's a uuid

package/src/const/settings/llm.ts

@@ -25,6 +25,7 @@ import {
   TaichuProviderCard,
   TogetherAIProviderCard,
   UpstageProviderCard,
+  WenxinProviderCard,
   ZeroOneProviderCard,
   ZhiPuProviderCard,
   filterEnabledModels,
@@ -141,6 +142,10 @@ export const DEFAULT_LLM_CONFIG: UserModelProviderConfig = {
     enabled: false,
     enabledModels: filterEnabledModels(UpstageProviderCard),
   },
+  wenxin: {
+    enabled: false,
+    enabledModels: filterEnabledModels(WenxinProviderCard),
+  },
   zeroone: {
     enabled: false,
     enabledModels: filterEnabledModels(ZeroOneProviderCard),

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

@@ -0,0 +1,49 @@
+import { Wenxin } from '@lobehub/icons';
+import { Input } from 'antd';
+import { memo } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { ModelProvider } from '@/libs/agent-runtime';
+import { useUserStore } from '@/store/user';
+import { keyVaultsConfigSelectors } from '@/store/user/selectors';
+
+import { FormAction } from '../style';
+
+const WenxinForm = memo(() => {
+  const { t } = useTranslation('modelProvider');
+
+  const [accessKey, secretKey, setConfig] = useUserStore((s) => [
+    keyVaultsConfigSelectors.wenxinConfig(s).accessKey,
+    keyVaultsConfigSelectors.wenxinConfig(s).secretKey,
+    s.updateKeyVaultConfig,
+  ]);
+
+  return (
+    <FormAction
+      avatar={<Wenxin.Color size={56} />}
+      description={t('wenxin.unlock.description')}
+      title={t('wenxin.unlock.title')}
+    >
+      <Input.Password
+        autoComplete={'new-password'}
+        onChange={(e) => {
+          setConfig(ModelProvider.Wenxin, { accessKey: e.target.value });
+        }}
+        placeholder={'Access Key'}
+        type={'block'}
+        value={accessKey}
+      />
+      <Input.Password
+        autoComplete={'new-password'}
+        onChange={(e) => {
+          setConfig(ModelProvider.Wenxin, { secretKey: e.target.value });
+        }}
+        placeholder={'Secret Key'}
+        type={'block'}
+        value={secretKey}
+      />
+    </FormAction>
+  );
+});
+
+export default WenxinForm;

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

@@ -10,6 +10,7 @@ import { GlobalLLMProviderKey } from '@/types/user/settings';
 
 import BedrockForm from './Bedrock';
 import ProviderApiKeyForm from './ProviderApiKeyForm';
+import WenxinForm from './Wenxin';
 
 interface APIKeyFormProps {
   id: string;
@@ -65,6 +66,8 @@ const APIKeyForm = memo<APIKeyFormProps>(({ id, provider }) => {
     <Center gap={16} style={{ maxWidth: 300 }}>
       {provider === ModelProvider.Bedrock ? (
         <BedrockForm />
+      ) : provider === ModelProvider.Wenxin ? (
+        <WenxinForm />
       ) : (
         <ProviderApiKeyForm
           apiKeyPlaceholder={apiKeyPlaceholder}

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

@@ -34,6 +34,7 @@ const getErrorAlertConfig = (
     };
 
   switch (errorType) {
+    case AgentRuntimeErrorType.QuotaLimitReached:
     case AgentRuntimeErrorType.LocationNotSupportError: {
       return {
         type: 'warning',

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

@@ -27,6 +27,7 @@ import {
   ModelProvider,
 } from '@/libs/agent-runtime';
 import { LobeStepfunAI } from '@/libs/agent-runtime/stepfun';
+import LobeWenxinAI from '@/libs/agent-runtime/wenxin';
 
 import { AgentChatOptions } from './AgentRuntime';
 import { LobeBedrockAIParams } from './bedrock';

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

@@ -3,6 +3,7 @@
 export const AgentRuntimeErrorType = {
   AgentRuntimeError: 'AgentRuntimeError', // Agent Runtime 模块运行时错误
   LocationNotSupportError: 'LocationNotSupportError',
+  QuotaLimitReached: 'QuotaLimitReached',
 
   InvalidProviderAPIKey: 'InvalidProviderAPIKey',
   ProviderBizError: 'ProviderBizError',

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

@@ -49,6 +49,7 @@ export enum ModelProvider {
   Taichu = 'taichu',
   TogetherAI = 'togetherai',
   Upstage = 'upstage',
+  Wenxin = 'wenxin',
   ZeroOne = 'zeroone',
   ZhiPu = 'zhipu',
 }