@lobehub/chat 1.51.2 → 1.51.4

package/src/server/modules/AgentRuntime/index.test.ts

@@ -25,7 +25,6 @@ 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 './index';
 
@@ -55,9 +54,6 @@ 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',
   })),
 }));
 
@@ -207,16 +203,6 @@ 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',
@@ -364,13 +350,6 @@ 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('OpenAI provider: without apikey with OPENAI_PROXY_URL', async () => {
       process.env.OPENAI_PROXY_URL = 'https://proxy.example.com/v1';
 

package/src/server/translation.test.ts

@@ -53,13 +53,6 @@ describe('getLocale', () => {
     expect(normalizeLocale).toHaveBeenCalledWith('fr-FR');
   });
 
-  it('should return the locale from cookie if available', async () => {
-    mockCookieStore.get.mockReturnValue({ value: 'de-DE' });
-    const result = await getLocale();
-    expect(result).toBe('de-DE');
-    expect(mockCookieStore.get).toHaveBeenCalledWith(LOBE_LOCALE_COOKIE);
-  });
-
   it('should return DEFAULT_LANG if no cookie is set', async () => {
     mockCookieStore.get.mockReturnValue(undefined);
     const result = await getLocale();

package/src/server/translation.ts

@@ -1,19 +1,16 @@
 'use server';
 
 import { get } from 'lodash-es';
-import { cookies } from 'next/headers';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
-import { DEFAULT_LANG, LOBE_LOCALE_COOKIE } from '@/const/locale';
+import { DEFAULT_LANG } from '@/const/locale';
 import { Locales, NS, normalizeLocale } from '@/locales/resources';
 import { isDev } from '@/utils/env';
 
 export const getLocale = async (hl?: string): Promise<Locales> => {
   if (hl) return normalizeLocale(hl) as Locales;
-  const cookieStore = await cookies();
-  const defaultLang = cookieStore.get(LOBE_LOCALE_COOKIE);
-  return (defaultLang?.value || DEFAULT_LANG) as Locales;
+  return DEFAULT_LANG as Locales;
 };
 
 export const translation = async (ns: NS = 'common', hl?: string) => {

package/src/services/_auth.ts

@@ -9,7 +9,6 @@ import {
   AzureOpenAIKeyVault,
   CloudflareKeyVault,
   OpenAICompatibleKeyVault,
-  WenxinKeyVault,
 } from '@/types/user/settings';
 import { createJWT } from '@/utils/jwt';
 
@@ -18,7 +17,6 @@ export const getProviderAuthPayload = (
   keyVaults: OpenAICompatibleKeyVault &
     AzureOpenAIKeyVault &
     AWSBedrockKeyVault &
-    WenxinKeyVault &
     CloudflareKeyVault,
 ) => {
   switch (provider) {
@@ -47,18 +45,6 @@ export const getProviderAuthPayload = (
       };
     }
 
-    case ModelProvider.Wenxin: {
-      const { secretKey, accessKey } = keyVaults;
-
-      const apiKey = (accessKey || '') + (secretKey || '');
-
-      return {
-        apiKey,
-        wenxinAccessKey: accessKey,
-        wenxinSecretKey: secretKey,
-      };
-    }
-
     case ModelProvider.Azure: {
       return {
         apiKey: keyVaults.apiKey,

package/src/store/chat/slices/portal/selectors.test.ts

@@ -1,16 +1,23 @@
 import { describe, expect, it } from 'vitest';
 
 import type { ChatStoreState } from '@/store/chat';
+import { ChatMessage } from '@/types/message';
 
 import { chatPortalSelectors } from './selectors';
 
 describe('chatDockSelectors', () => {
-  const createState = (overrides?: Partial<ChatStoreState>) =>
-    ({
+  const createState = (overrides?: Partial<ChatStoreState>) => {
+    const state = {
       showPortal: false,
       portalToolMessage: undefined,
+      messagesMap: {},
+      activeId: 'test-id',
+      activeTopicId: undefined,
       ...overrides,
-    }) as ChatStoreState;
+    } as ChatStoreState;
+
+    return state;
+  };
 
   describe('showDock', () => {
     it('should return the showDock state', () => {
@@ -92,4 +99,163 @@ describe('chatDockSelectors', () => {
       expect(chatPortalSelectors.previewFileId(state)).toBe('file-id');
     });
   });
+
+  describe('artifactMessageContent', () => {
+    it('should return empty string when message not found', () => {
+      const state = createState();
+      expect(chatPortalSelectors.artifactMessageContent('non-existent-id')(state)).toBe('');
+    });
+
+    it('should return message content when message exists', () => {
+      const messageContent = 'Test message content';
+      const state = createState({
+        messagesMap: {
+          'test-id_null': [
+            {
+              id: 'test-id',
+              content: messageContent,
+              createdAt: Date.now(),
+              updatedAt: Date.now(),
+              role: 'user',
+              meta: {},
+              sessionId: 'test-id',
+            } as ChatMessage,
+          ],
+        },
+      });
+      expect(chatPortalSelectors.artifactMessageContent('test-id')(state)).toBe(messageContent);
+    });
+  });
+
+  describe('artifactCode', () => {
+    it('should return empty string when no artifact tag found', () => {
+      const state = createState({
+        messagesMap: {
+          'test-id_null': [
+            {
+              id: 'test-id',
+              content: 'No artifact tag here',
+              createdAt: Date.now(),
+              updatedAt: Date.now(),
+              role: 'user',
+              meta: {},
+              sessionId: 'test-id',
+            } as ChatMessage,
+          ],
+        },
+      });
+      expect(chatPortalSelectors.artifactCode('test-id')(state)).toBe('');
+    });
+
+    it('should extract content from artifact tag', () => {
+      const artifactContent = 'Test artifact content';
+      const state = createState({
+        messagesMap: {
+          'test-id_null': [
+            {
+              id: 'test-id',
+              content: `<lobeArtifact type="text">${artifactContent}</lobeArtifact>`,
+              createdAt: Date.now(),
+              updatedAt: Date.now(),
+              role: 'user',
+              meta: {},
+              sessionId: 'test-id',
+            } as ChatMessage,
+          ],
+        },
+      });
+      expect(chatPortalSelectors.artifactCode('test-id')(state)).toBe(artifactContent);
+    });
+
+    it('should remove markdown code block wrapping HTML content', () => {
+      const htmlContent = `<!DOCTYPE html>
+<html>
+<head>
+  <title>Test</title>
+</head>
+<body>
+  <div>Test content</div>
+</body>
+</html>`;
+      const state = createState({
+        messagesMap: {
+          'test-id_null': [
+            {
+              id: 'test-id',
+              content: `<lobeArtifact type="text/html">
+\`\`\`html
+${htmlContent}
+\`\`\`
+</lobeArtifact>`,
+              createdAt: Date.now(),
+              updatedAt: Date.now(),
+              role: 'user',
+              meta: {},
+              sessionId: 'test-id',
+            } as ChatMessage,
+          ],
+        },
+      });
+      expect(chatPortalSelectors.artifactCode('test-id')(state)).toBe(htmlContent);
+    });
+  });
+
+  describe('isArtifactTagClosed', () => {
+    it('should return false for unclosed artifact tag', () => {
+      const state = createState({
+        messagesMap: {
+          'test-id_null': [
+            {
+              id: 'test-id',
+              content: '<lobeArtifact type="text">Test content',
+              createdAt: Date.now(),
+              updatedAt: Date.now(),
+              role: 'user',
+              meta: {},
+              sessionId: 'test-id',
+            } as ChatMessage,
+          ],
+        },
+      });
+      expect(chatPortalSelectors.isArtifactTagClosed('test-id')(state)).toBe(false);
+    });
+
+    it('should return true for closed artifact tag', () => {
+      const state = createState({
+        messagesMap: {
+          'test-id_null': [
+            {
+              id: 'test-id',
+              content: '<lobeArtifact type="text">Test content</lobeArtifact>',
+              createdAt: Date.now(),
+              updatedAt: Date.now(),
+              role: 'user',
+              meta: {},
+              sessionId: 'test-id',
+            } as ChatMessage,
+          ],
+        },
+      });
+      expect(chatPortalSelectors.isArtifactTagClosed('test-id')(state)).toBe(true);
+    });
+
+    it('should return false when no artifact tag exists', () => {
+      const state = createState({
+        messagesMap: {
+          'test-id_null': [
+            {
+              id: 'test-id',
+              content: 'No artifact tag here',
+              createdAt: Date.now(),
+              updatedAt: Date.now(),
+              role: 'user',
+              meta: {},
+              sessionId: 'test-id',
+            } as ChatMessage,
+          ],
+        },
+      });
+      expect(chatPortalSelectors.isArtifactTagClosed('test-id')(state)).toBe(false);
+    });
+  });
 });

package/src/store/chat/slices/portal/selectors.ts

@@ -35,7 +35,12 @@ const artifactCode = (id: string) => (s: ChatStoreState) => {
   const messageContent = artifactMessageContent(id)(s);
   const result = messageContent.match(ARTIFACT_TAG_REGEX);
 
-  return result?.groups?.content || '';
+  let content = result?.groups?.content || '';
+
+  // Remove markdown code block if content is wrapped
+  content = content.replace(/^\s*```[^\n]*\n([\S\s]*?)\n```\s*$/, '$1');
+
+  return content;
 };
 
 const isArtifactTagClosed = (id: string) => (s: ChatStoreState) => {

package/src/store/user/slices/modelList/selectors/keyVaults.ts

@@ -14,7 +14,6 @@ export const keyVaultsSettings = (s: UserStore): UserKeyVaults =>
 
 const openAIConfig = (s: UserStore) => keyVaultsSettings(s).openai || {};
 const bedrockConfig = (s: UserStore) => keyVaultsSettings(s).bedrock || {};
-const wenxinConfig = (s: UserStore) => keyVaultsSettings(s).wenxin || {};
 const ollamaConfig = (s: UserStore) => keyVaultsSettings(s).ollama || {};
 const azureConfig = (s: UserStore) => keyVaultsSettings(s).azure || {};
 const cloudflareConfig = (s: UserStore) => keyVaultsSettings(s).cloudflare || {};
@@ -45,5 +44,4 @@ export const keyVaultsConfigSelectors = {
   ollamaConfig,
   openAIConfig,
   password,
-  wenxinConfig,
 };

package/src/types/aiProvider.ts

@@ -23,7 +23,6 @@ export const AiProviderSDKEnum = {
   Huggingface: 'huggingface',
   Ollama: 'ollama',
   Openai: 'openai',
-  Wenxin: 'wenxin',
 } as const;
 
 export type AiProviderSDKType = (typeof AiProviderSDKEnum)[keyof typeof AiProviderSDKEnum];

package/src/types/discover.ts

@@ -7,7 +7,10 @@ import { MetaData } from '@/types/meta';
 import { PageProps } from '@/types/next';
 import { LobeAgentSettings } from '@/types/session';
 
-export type DiscoverPageProps<T = string> = PageProps<{ slug: T }, { hl?: Locales }>;
+export type DiscoverPageProps<T = string> = PageProps<
+  { slug: T; variants: string },
+  { hl?: Locales }
+>;
 
 export enum AssistantCategory {
   Academic = 'academic',

package/src/types/next.ts

@@ -4,3 +4,7 @@ export interface PageProps<Params, SearchParams = undefined> {
 }
 
 export type PagePropsWithId = PageProps<{ id: string }>;
+
+export interface DynamicLayoutProps {
+  params: Promise<{ variants: string }>;
+}

package/src/types/user/settings/keyVaults.ts

@@ -25,11 +25,6 @@ export interface CloudflareKeyVault {
   baseURLOrAccountID?: string;
 }
 
-export interface WenxinKeyVault {
-  accessKey?: string;
-  secretKey?: string;
-}
-
 export interface UserKeyVaults {
   ai21?: OpenAICompatibleKeyVault;
   ai360?: OpenAICompatibleKeyVault;
@@ -68,7 +63,7 @@ export interface UserKeyVaults {
   taichu?: OpenAICompatibleKeyVault;
   togetherai?: OpenAICompatibleKeyVault;
   upstage?: OpenAICompatibleKeyVault;
-  wenxin?: WenxinKeyVault;
+  wenxin?: OpenAICompatibleKeyVault;
   xai?: OpenAICompatibleKeyVault;
   zeroone?: OpenAICompatibleKeyVault;
   zhipu?: OpenAICompatibleKeyVault;

package/src/utils/locale.ts

@@ -1,7 +1,8 @@
 import { resolveAcceptLanguage } from 'resolve-accept-language';
 
 import { DEFAULT_LANG } from '@/const/locale';
-import { locales, normalizeLocale } from '@/locales/resources';
+import { Locales, locales, normalizeLocale } from '@/locales/resources';
+import { RouteVariants } from '@/utils/server/routeVariants';
 
 export const getAntdLocale = async (lang?: string) => {
   let normalLang = normalizeLocale(lang);
@@ -32,14 +33,29 @@ export const parseBrowserLanguage = (headers: Headers, defaultLang: string = DEF
    * 2) The available locales (they must contain the default locale).
    * 3) The default locale.
    */
-  let fallbackLang: string = resolveAcceptLanguage(
+  let browserLang: string = resolveAcceptLanguage(
     headers.get('accept-language') || '',
     //  Invalid locale identifier 'ar'. A valid locale should follow the BCP 47 'language-country' format.
     locales.map((locale) => (locale === 'ar' ? 'ar-EG' : locale)),
     defaultLang,
   );
+
   // if match the ar-EG then fallback to ar
-  if (fallbackLang === 'ar-EG') fallbackLang = 'ar';
+  if (browserLang === 'ar-EG') browserLang = 'ar';
+
+  return browserLang;
+};
 
-  return fallbackLang;
+/**
+ * Parse the page locale from the URL and search params
+ * @param props
+ */
+export const parsePageLocale = async (props: {
+  params: Promise<{ variants: string }>;
+  searchParams: Promise<any>;
+}) => {
+  const searchParams = await props.searchParams;
+
+  const browserLocale = await RouteVariants.getLocale(props);
+  return normalizeLocale(searchParams?.hl || browserLocale) as Locales;
 };

package/src/utils/server/routeVariants.ts

@@ -0,0 +1,80 @@
+// 定义主题类型
+import { ThemeAppearance } from 'antd-style/lib/types/appearance';
+
+import { DEFAULT_LANG } from '@/const/locale';
+import { locales } from '@/locales/resources';
+import { DynamicLayoutProps } from '@/types/next';
+
+// 定义变体接口
+export interface IRouteVariants {
+  isMobile: boolean;
+  locale: string;
+  neutralColor?: string;
+  primaryColor?: string;
+  theme: ThemeAppearance;
+}
+
+// 支持的主题
+const SUPPORTED_THEMES = ['dark', 'light'] as const;
+
+// 默认变体配置
+export const DEFAULT_VARIANTS: IRouteVariants = {
+  isMobile: false,
+  locale: DEFAULT_LANG,
+  theme: 'light',
+};
+
+const SPLITTER = '__';
+
+export class RouteVariants {
+  static serializeVariants = (variants: IRouteVariants): string => {
+    // 使用紧凑的格式: locale_isMobile_theme
+    // 例如: "en-US_0_dark" 表示 英文_非移动端_深色主题
+    return [variants.locale, Number(variants.isMobile), variants.theme].join(SPLITTER);
+  };
+
+  static deserializeVariants = (serialized: string): IRouteVariants => {
+    try {
+      const [locale, isMobile, theme] = serialized.split(SPLITTER);
+
+      // 验证并返回变体
+      return {
+        isMobile: isMobile === '1',
+        locale: this.isValidLocale(locale) ? locale : DEFAULT_VARIANTS.locale,
+        theme: this.isValidTheme(theme) ? theme : DEFAULT_VARIANTS.theme,
+      };
+    } catch {
+      // 解析失败时返回默认值
+      return { ...DEFAULT_VARIANTS };
+    }
+  };
+
+  static getVariantsFromProps = async (props: DynamicLayoutProps) => {
+    const { variants } = await props.params;
+    return RouteVariants.deserializeVariants(variants);
+  };
+
+  static getIsMobile = async (props: DynamicLayoutProps) => {
+    const { variants } = await props.params;
+    const { isMobile } = RouteVariants.deserializeVariants(variants);
+    return isMobile;
+  };
+
+  static getLocale = async (props: DynamicLayoutProps) => {
+    const { variants } = await props.params;
+    const { locale } = RouteVariants.deserializeVariants(variants);
+    return locale;
+  };
+
+  // 工具函数：创建变体
+
+  static createVariants = (options: Partial<IRouteVariants> = {}): IRouteVariants => ({
+    ...DEFAULT_VARIANTS,
+    ...options,
+  });
+
+  // 验证函数
+  private static isValidLocale = (locale: string): boolean => locales.includes(locale as any);
+
+  private static isValidTheme = (theme: string): boolean => SUPPORTED_THEMES.includes(theme as any);
+}

package/src/app/(backend)/webapi/chat/wenxin/route.test.ts

@@ -1,27 +0,0 @@
-// @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: Promise.resolve({ provider: 'wenxin' }),
-    });
-  });
-});

package/src/app/(backend)/webapi/chat/wenxin/route.ts

@@ -1,30 +0,0 @@
-import { getLLMConfig } from '@/config/llm';
-import { AgentRuntime, ModelProvider } 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: Promise.resolve({ provider: ModelProvider.Wenxin }),
-  });

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

@@ -1,44 +0,0 @@
-'use client';
-
-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'],
-      },
-    ],
-  };
-};

package/src/app/(main)/settings/provider/(detail)/wenxin/page.tsx

@@ -1,61 +0,0 @@
-'use client';
-
-import { useTranslation } from 'react-i18next';
-
-import { FormPassword } from '@/components/FormInput';
-import { WenxinProviderCard } from '@/config/modelProviders';
-import { aiProviderSelectors, useAiInfraStore } from '@/store/aiInfra';
-import { GlobalLLMProviderKey } from '@/types/user/settings';
-
-import { KeyVaultsConfigKey } from '../../const';
-import { SkeletonInput } from '../../features/ProviderConfig';
-import { ProviderItem } from '../../type';
-import ProviderDetail from '../[id]';
-
-const providerKey: GlobalLLMProviderKey = 'wenxin';
-
-const useProviderCard = (): ProviderItem => {
-  const { t } = useTranslation('modelProvider');
-
-  const isLoading = useAiInfraStore(aiProviderSelectors.isAiProviderConfigLoading(providerKey));
-
-  return {
-    ...WenxinProviderCard,
-    apiKeyItems: [
-      {
-        children: isLoading ? (
-          <SkeletonInput />
-        ) : (
-          <FormPassword
-            autoComplete={'new-password'}
-            placeholder={t(`${providerKey}.accessKey.placeholder`)}
-          />
-        ),
-        desc: t(`${providerKey}.accessKey.desc`),
-        label: t(`${providerKey}.accessKey.title`),
-        name: [KeyVaultsConfigKey, 'accessKey'],
-      },
-      {
-        children: isLoading ? (
-          <SkeletonInput />
-        ) : (
-          <FormPassword
-            autoComplete={'new-password'}
-            placeholder={t(`${providerKey}.secretKey.placeholder`)}
-          />
-        ),
-        desc: t(`${providerKey}.secretKey.desc`),
-        label: t(`${providerKey}.secretKey.title`),
-        name: [KeyVaultsConfigKey, 'secretKey'],
-      },
-    ],
-  };
-};
-
-const Page = () => {
-  const card = useProviderCard();
-
-  return <ProviderDetail {...card} />;
-};
-
-export default Page;