@lobehub/chat 1.51.2 → 1.51.3

package/src/features/DevPanel/{PostgresViewer/DataTable/Table.tsx → features/Table/index.tsx}

@@ -1,9 +1,10 @@
+import { Icon } from '@lobehub/ui';
 import { createStyles } from 'antd-style';
+import { Loader2Icon } from 'lucide-react';
 import React from 'react';
 import { Center } from 'react-layout-kit';
 import { TableVirtuoso } from 'react-virtuoso';
 
-import { usePgTable, useTableColumns } from '../usePgTable';
 import TableCell from './TableCell';
 
 const useStyles = createStyles(({ token, css }) => ({
@@ -88,24 +89,21 @@ const useStyles = createStyles(({ token, css }) => ({
 }));
 
 interface TableProps {
-  tableName?: string;
+  columns: string[];
+  dataSource: any[];
+  loading?: boolean;
 }
 
-const Table = ({ tableName }: TableProps) => {
+const Table = ({ columns, dataSource, loading }: TableProps) => {
   const { styles } = useStyles();
 
-  const tableColumns = useTableColumns(tableName);
+  if (loading)
+    return (
+      <Center height={'100%'}>
+        <Icon icon={Loader2Icon} spin />
+      </Center>
+    );
 
-  const tableData = usePgTable(tableName);
-
-  const columns = tableColumns.data?.map((t) => t.name) || [];
-  const isLoading = tableColumns.isLoading || tableData.isLoading;
-
-  if (!tableName) return <Center height={'80%'}>Select a table to view data</Center>;
-
-  if (isLoading) return <Center height={'80%'}>Loading...</Center>;
-
-  const dataSource = tableData.data?.data || [];
   const header = (
     <tr>
       {columns.map((column) => (

package/src/features/DevPanel/index.tsx

@@ -1,12 +1,36 @@
-'use client';
+import { BookText, DatabaseIcon, FlagIcon, GlobeLockIcon } from 'lucide-react';
 
-import FloatPanel from './FloatPanel';
+import CacheViewer from './CacheViewer';
+import FeatureFlagViewer from './FeatureFlagViewer';
+import MetadataViewer from './MetadataViewer';
 import PostgresViewer from './PostgresViewer';
+import FloatPanel from './features/FloatPanel';
 
 const DevPanel = () => (
-  <FloatPanel>
-    <PostgresViewer />
-  </FloatPanel>
+  <FloatPanel
+    items={[
+      {
+        children: <PostgresViewer />,
+        icon: <DatabaseIcon size={16} />,
+        key: 'Postgres Viewer',
+      },
+      {
+        children: <MetadataViewer />,
+        icon: <BookText size={16} />,
+        key: 'SEO Metadata',
+      },
+      {
+        children: <CacheViewer />,
+        icon: <GlobeLockIcon size={16} />,
+        key: 'NextJS Caches',
+      },
+      {
+        children: <FeatureFlagViewer />,
+        icon: <FlagIcon size={16} />,
+        key: 'Feature Flags',
+      },
+    ]}
+  />
 );
 
 export default DevPanel;

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

@@ -26,7 +26,6 @@ import {
   ModelProvider,
 } from '@/libs/agent-runtime';
 import { LobeStepfunAI } from '@/libs/agent-runtime/stepfun';
-import LobeWenxinAI from '@/libs/agent-runtime/wenxin';
 import { createTraceOptions } from '@/server/modules/AgentRuntime';
 
 import { AgentChatOptions } from './AgentRuntime';

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

@@ -47,6 +47,7 @@ import {
   TextToSpeechPayload,
 } from './types';
 import { LobeUpstageAI } from './upstage';
+import { LobeWenxinAI } from './wenxin';
 import { LobeXAI } from './xai';
 import { LobeZeroOneAI } from './zeroone';
 import { LobeZhipuAI } from './zhipu';
@@ -167,6 +168,7 @@ class AgentRuntime {
       taichu: Partial<ClientOptions>;
       togetherai: Partial<ClientOptions>;
       upstage: Partial<ClientOptions>;
+      wenxin: Partial<ClientOptions>;
       xai: Partial<ClientOptions>;
       zeroone: Partial<ClientOptions>;
       zhipu: Partial<ClientOptions>;
@@ -370,6 +372,11 @@ class AgentRuntime {
         runtimeModel = new LobeDoubaoAI(params.doubao);
         break;
       }
+
+      case ModelProvider.Wenxin: {
+        runtimeModel = new LobeWenxinAI(params.wenxin);
+        break;
+      }
     }
     return new AgentRuntime(runtimeModel);
   }

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

@@ -1,107 +1,10 @@
-import { ChatCompletion } from '@baiducloud/qianfan';
-
-// 如果引入了这个类型，那么在跑 type-check 的 tsc 检查中就会抛错，大无语
-// import type QianFanClient from '@baiducloud/qianfan/src/ChatCompletion/index';
-import { safeParseJSON } from '@/utils/safeParseJSON';
-
-import { LobeRuntimeAI } from '../BaseAI';
-import { AgentRuntimeErrorType } from '../error';
-import { ChatCompetitionOptions, ChatStreamPayload } from '../types';
-import { AgentRuntimeError } from '../utils/createError';
-import { debugStream } from '../utils/debugStream';
-import { StreamingResponse } from '../utils/response';
-import { convertIterableToStream } from '../utils/streams';
-import { WenxinStream } from '../utils/streams/wenxin';
-import { ChatResp } from './type';
-
-interface ChatErrorCode {
-  error_code: number;
-  error_msg: string;
-}
-
-export interface LobeWenxinAIParams {
-  accessKey?: string;
-  baseURL?: string;
-  secretKey?: string;
-}
-
-export class LobeWenxinAI implements LobeRuntimeAI {
-  private client: any;
-  baseURL?: string;
-
-  constructor({ accessKey, baseURL, secretKey }: LobeWenxinAIParams = {}) {
-    if (!accessKey || !secretKey)
-      throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidProviderAPIKey);
-
-    this.client = new ChatCompletion({
-      QIANFAN_ACCESS_KEY: accessKey,
-      QIANFAN_SECRET_KEY: secretKey,
-    });
-    this.baseURL = baseURL;
-  }
-
-  async chat(payload: ChatStreamPayload, options?: ChatCompetitionOptions) {
-    try {
-      const result = await this.client.chat(
-        { messages: payload.messages as any, stream: true, user_id: options?.user },
-        payload.model,
-      );
-
-      const wenxinStream = convertIterableToStream(result as AsyncIterable<ChatResp>);
-
-      const [prod, useForDebug] = wenxinStream.tee();
-
-      if (process.env.DEBUG_WENXIN_CHAT_COMPLETION === '1') {
-        debugStream(useForDebug).catch();
-      }
-
-      const stream = WenxinStream(prod, options?.callback);
-
-      // Respond with the stream
-      return StreamingResponse(stream, { headers: options?.headers });
-    } catch (e) {
-      const err = e as Error;
-
-      const error: ChatErrorCode | undefined = safeParseJSON(err.message);
-
-      if (!error) {
-        throw AgentRuntimeError.createError(AgentRuntimeErrorType.AgentRuntimeError, {
-          message: err.message,
-          name: err.name,
-        });
-      }
-
-      // 文心一言错误码
-      // https://cloud.baidu.com/doc/WENXINWORKSHOP/s/tlmyncueh
-      switch (error.error_code) {
-        // Invalid API key or access key
-        case 100:
-        case 13:
-        case 14: {
-          throw AgentRuntimeError.createError(AgentRuntimeErrorType.InvalidProviderAPIKey, error);
-        }
-
-        // quota limit
-        case 4:
-        case 17:
-        case 18:
-        case 19:
-        case 336_501:
-        case 336_502:
-        case 336_503:
-        case 336_504:
-        case 336_505:
-        case 336_507: {
-          throw AgentRuntimeError.createError(AgentRuntimeErrorType.QuotaLimitReached, {
-            errorCode: error.error_code,
-            message: `${error.error_msg} | you can visit https://cloud.baidu.com/doc/WENXINWORKSHOP/s/tlmyncueh for more information about the error code`,
-          });
-        }
-      }
-
-      throw AgentRuntimeError.createError(AgentRuntimeErrorType.ProviderBizError, error);
-    }
-  }
-}
-
-export default LobeWenxinAI;
+import { ModelProvider } from '../types';
+import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
+
+export const LobeWenxinAI = LobeOpenAICompatibleFactory({
+  baseURL: 'https://qianfan.baidubce.com/v2',
+  debug: {
+    chatCompletion: () => process.env.DEBUG_WENXIN_CHAT_COMPLETION === '1',
+  },
+  provider: ModelProvider.Wenxin,
+});

package/src/locales/default/modelProvider.ts

@@ -296,26 +296,6 @@ export default {
     tooltip: '更新服务商基础配置',
     updateSuccess: '更新成功',
   },
-  wenxin: {
-    accessKey: {
-      desc: '填入百度千帆平台的 Access Key',
-      placeholder: 'Qianfan Access Key',
-      title: 'Access Key',
-    },
-    checker: {
-      desc: '测试 AccessKey / SecretAccess 是否填写正确',
-    },
-    secretKey: {
-      desc: '填入百度千帆平台 Secret Key',
-      placeholder: 'Qianfan Secret Key',
-      title: 'Secret Key',
-    },
-    unlock: {
-      customRegion: '自定义服务区域',
-      description: '输入你的 AccessKey / SecretKey 即可开始会话。应用不会记录你的鉴权配置',
-      title: '使用自定义文心一言鉴权信息',
-    },
-  },
   zeroone: {
     title: '01.AI 零一万物',
   },

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/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/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/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 }),
-  });