@lobehub/chat 1.124.0 → 1.124.1

package/src/config/llm.ts

@@ -186,6 +186,10 @@ export const getLLMConfig = () => {
 
       ENABLED_AIHUBMIX: z.boolean(),
       AIHUBMIX_API_KEY: z.string().optional(),
+
+      ENABLED_NEWAPI: z.boolean(),
+      NEWAPI_API_KEY: z.string().optional(),
+      NEWAPI_PROXY_URL: z.string().optional(),
     },
     runtimeEnv: {
       API_KEY_SELECT_MODE: process.env.API_KEY_SELECT_MODE,
@@ -368,6 +372,10 @@ export const getLLMConfig = () => {
       ENABLED_AIHUBMIX: !!process.env.AIHUBMIX_API_KEY,
       AIHUBMIX_API_KEY: process.env.AIHUBMIX_API_KEY,
 
+      ENABLED_NEWAPI: !!process.env.NEWAPI_API_KEY,
+      NEWAPI_API_KEY: process.env.NEWAPI_API_KEY,
+      NEWAPI_PROXY_URL: process.env.NEWAPI_PROXY_URL,
+
       ENABLED_NEBIUS: !!process.env.NEBIUS_API_KEY,
       NEBIUS_API_KEY: process.env.NEBIUS_API_KEY,
     },

package/src/features/ChatInput/Desktop/index.tsx

@@ -1,9 +1,11 @@
 'use client';
 
 import { ChatInput, ChatInputActionBar } from '@lobehub/editor/react';
+import { Text } from '@lobehub/ui';
 import { createStyles } from 'antd-style';
 import { memo, useEffect } from 'react';
-import { Flexbox } from 'react-layout-kit';
+import { useTranslation } from 'react-i18next';
+import { Center, Flexbox } from 'react-layout-kit';
 
 import { useChatInputStore } from '@/features/ChatInput/store';
 import { useChatStore } from '@/store/chat';
@@ -12,7 +14,6 @@ import { chatSelectors } from '@/store/chat/selectors';
 import ActionBar from '../ActionBar';
 import InputEditor from '../InputEditor';
 import SendArea from '../SendArea';
-import ShortcutHint from '../SendArea/ShortcutHint';
 import TypoBar from '../TypoBar';
 import FilePreview from './FilePreview';
 
@@ -28,6 +29,9 @@ const useStyles = createStyles(({ css, token }) => ({
       }
     }
   `,
+  footnote: css`
+    font-size: 10px;
+  `,
   fullscreen: css`
     position: absolute;
     z-index: 100;
@@ -42,6 +46,7 @@ const useStyles = createStyles(({ css, token }) => ({
 }));
 
 const DesktopChatInput = memo<{ showFootnote?: boolean }>(({ showFootnote }) => {
+  const { t } = useTranslation('chat');
   const [slashMenuRef, expand, showTypoBar, editor, leftActions] = useChatInputStore((s) => [
     s.slashMenuRef,
     s.expand,
@@ -65,7 +70,8 @@ const DesktopChatInput = memo<{ showFootnote?: boolean }>(({ showFootnote }) =>
       {!expand && fileNode}
       <Flexbox
         className={cx(styles.container, expand && styles.fullscreen)}
-        paddingBlock={showFootnote ? 0 : '0 12px'}
+        gap={8}
+        paddingBlock={showFootnote ? '0 8px' : '0 12px'}
         paddingInline={12}
       >
         <ChatInput
@@ -85,7 +91,13 @@ const DesktopChatInput = memo<{ showFootnote?: boolean }>(({ showFootnote }) =>
           {expand && fileNode}
           <InputEditor />
         </ChatInput>
-        {showFootnote && !expand && <ShortcutHint />}
+        {showFootnote && !expand && (
+          <Center style={{ pointerEvents: 'none', zIndex: 100 }}>
+            <Text className={styles.footnote} type={'secondary'}>
+              {t('input.disclaimer')}
+            </Text>
+          </Center>
+        )}
       </Flexbox>
     </>
   );

package/src/locales/default/chat.ts

@@ -71,6 +71,7 @@ export default {
   input: {
     addAi: '添加一条 AI 消息',
     addUser: '添加一条用户消息',
+    disclaimer: 'AI 也可能会犯错，请检查重要信息',
     errorMsg: '消息发送失败，请检查网络后重试: {{errorMsg}}',
     more: '更多',
     send: '发送',

package/src/locales/default/modelProvider.ts

@@ -164,7 +164,7 @@ export default {
       title: 'API 密钥',
     },
     apiUrl: {
-      desc: 'New API 服务的 API 地址，大部分时候需要带 /v1',
+      desc: 'New API 服务的 API 地址，大部分时候不要带 /v1',
       title: 'API 地址',
     },
     enabled: {

package/src/store/chat/slices/aiChat/actions/__tests__/cancel-functionality.test.ts

@@ -0,0 +1,107 @@
+import { act, renderHook } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { useChatStore } from '../../../../store';
+
+describe('Cancel send message functionality tests', () => {
+  describe('cancelSendMessageInServer', () => {
+    it('should be able to call cancel method normally', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      // Initial state setup
+      act(() => {
+        useChatStore.setState({
+          activeId: 'session-1',
+          activeTopicId: 'topic-1',
+          mainSendMessageOperations: {},
+        });
+      });
+
+      // Test method exists
+      expect(typeof result.current.cancelSendMessageInServer).toBe('function');
+
+      // Test method can be called safely
+      expect(() => {
+        act(() => {
+          result.current.cancelSendMessageInServer();
+        });
+      }).not.toThrow();
+    });
+
+    it('should be able to call with specified topic ID', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        useChatStore.setState({
+          activeId: 'session-1',
+          mainSendMessageOperations: {},
+        });
+      });
+
+      expect(() => {
+        act(() => {
+          result.current.cancelSendMessageInServer('topic-2');
+        });
+      }).not.toThrow();
+    });
+  });
+
+  describe('clearSendMessageError', () => {
+    it('should be able to call clear error method normally', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        useChatStore.setState({
+          activeId: 'session-1',
+          activeTopicId: 'topic-1',
+          mainSendMessageOperations: {},
+        });
+      });
+
+      expect(typeof result.current.clearSendMessageError).toBe('function');
+
+      expect(() => {
+        act(() => {
+          result.current.clearSendMessageError();
+        });
+      }).not.toThrow();
+    });
+  });
+
+  describe('Internal methods', () => {
+    it('should have internal state management methods', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      expect(typeof result.current.internal_toggleSendMessageOperation).toBe('function');
+      expect(typeof result.current.internal_updateSendMessageOperation).toBe('function');
+    });
+
+    it('internal_toggleSendMessageOperation should work normally', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        useChatStore.setState({ mainSendMessageOperations: {} });
+      });
+
+      expect(() => {
+        act(() => {
+          const abortController = result.current.internal_toggleSendMessageOperation(
+            'test-key',
+            true,
+          );
+          expect(abortController).toBeInstanceOf(AbortController);
+        });
+      }).not.toThrow();
+    });
+  });
+
+  describe('State structure', () => {
+    it('should have mainSendMessageOperations state', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      // Ensure state exists
+      expect(result.current.mainSendMessageOperations).toBeDefined();
+      expect(typeof result.current.mainSendMessageOperations).toBe('object');
+    });
+  });
+});

package/src/store/chat/slices/aiChat/actions/__tests__/generateAIChatV2.test.ts

@@ -1,4 +1,5 @@
 import { act, renderHook } from '@testing-library/react';
+import { TRPCClientError } from '@trpc/client';
 import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { LOADING_FLAT } from '@/const/message';
@@ -10,7 +11,6 @@ import {
 } from '@/const/settings';
 import { aiChatService } from '@/services/aiChat';
 import { chatService } from '@/services/chat';
-//
 import { messageService } from '@/services/message';
 import { agentChatConfigSelectors, agentSelectors } from '@/store/agent/selectors';
 import { sessionMetaSelectors } from '@/store/session/selectors';
@@ -18,6 +18,8 @@ import { UploadFileItem } from '@/types/files/upload';
 import { ChatMessage } from '@/types/message';
 
 import { useChatStore } from '../../../../store';
+import { messageMapKey } from '../../../../utils/messageMapKey';
+import { generateAIChatV2 } from '../generateAIChatV2';
 
 vi.stubGlobal(
   'fetch',
@@ -115,7 +117,10 @@ const mockState = {
   refreshTopic: vi.fn(),
   internal_execAgentRuntime: vi.fn(),
   saveToTopic: vi.fn(),
-};
+  switchTopic: vi.fn(),
+  internal_shouldUseRAG: () => false,
+  internal_retrieveChunks: vi.fn(),
+} as any;
 
 beforeEach(() => {
   vi.clearAllMocks();
@@ -136,11 +141,11 @@ afterEach(() => {
 describe('generateAIChatV2 actions', () => {
   describe('sendMessageInServer', () => {
     it('should not send message if there is no active session', async () => {
-      useChatStore.setState({ activeId: undefined });
       const { result } = renderHook(() => useChatStore());
       const message = 'Test message';
 
       await act(async () => {
+        useChatStore.setState({ activeId: undefined });
         await result.current.sendMessage({ message });
       });
 
@@ -252,7 +257,7 @@ describe('generateAIChatV2 actions', () => {
       expect(result.current.internal_execAgentRuntime).not.toHaveBeenCalled();
     });
 
-    it('当 isWelcomeQuestion 为 true 时,正确地传递给 internal_execAgentRuntime', async () => {
+    it('should pass isWelcomeQuestion correctly to internal_execAgentRuntime when isWelcomeQuestion is true', async () => {
       const { result } = renderHook(() => useChatStore());
 
       await act(async () => {
@@ -266,7 +271,7 @@ describe('generateAIChatV2 actions', () => {
       );
     });
 
-    it('当只有文件而没有消息内容时,正确发送消息', async () => {
+    it('should send message correctly when only files are provided without message content', async () => {
       const { result } = renderHook(() => useChatStore());
 
       await act(async () => {
@@ -290,7 +295,7 @@ describe('generateAIChatV2 actions', () => {
       );
     });
 
-    it('当同时有文件和消息内容时,正确发送消息并关联文件', async () => {
+    it('should send message correctly when both files and message content are provided', async () => {
       const { result } = renderHook(() => useChatStore());
 
       await act(async () => {
@@ -314,7 +319,7 @@ describe('generateAIChatV2 actions', () => {
       );
     });
 
-    it('当 createMessage 抛出错误时,正确处理错误而不影响整个应用', async () => {
+    it('should handle errors correctly when createMessage throws error without affecting the app', async () => {
       const { result } = renderHook(() => useChatStore());
       vi.spyOn(aiChatService, 'sendMessageInServer').mockRejectedValue(
         new Error('create message error'),
@@ -443,4 +448,344 @@ describe('generateAIChatV2 actions', () => {
       expect(mockState.refreshMessages).toHaveBeenCalled();
     });
   });
+
+  describe('Error handling tests', () => {
+    it('should set error message when sendMessageInServer throws a regular error', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const errorMessage = 'Network error';
+      const mockError = new TRPCClientError(errorMessage);
+      (mockError as any).data = { code: 'BAD_REQUEST' };
+
+      vi.spyOn(aiChatService, 'sendMessageInServer').mockRejectedValue(mockError);
+
+      await act(async () => {
+        await result.current.sendMessage({ message: 'test' });
+      });
+
+      const operationKey = messageMapKey('session-id', 'topic-id');
+      expect(result.current.mainSendMessageOperations[operationKey]?.inputSendErrorMsg).toBe(
+        errorMessage,
+      );
+    });
+
+    it('should not set error message when receiving a cancel signal', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const abortError = new Error('AbortError');
+      abortError.name = 'AbortError';
+
+      vi.spyOn(aiChatService, 'sendMessageInServer').mockRejectedValue(abortError);
+
+      await act(async () => {
+        await result.current.sendMessage({ message: 'test' });
+      });
+
+      const operationKey = messageMapKey('session-id', 'topic-id');
+      expect(
+        result.current.mainSendMessageOperations[operationKey]?.inputSendErrorMsg,
+      ).toBeUndefined();
+    });
+  });
+
+  describe('Topic switching tests', () => {
+    it('should automatically switch to newly created topic when no active topic exists', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const mockSwitchTopic = vi.fn();
+
+      await act(async () => {
+        useChatStore.setState({
+          ...mockState,
+          activeTopicId: undefined,
+          switchTopic: mockSwitchTopic,
+        });
+        await result.current.sendMessage({ message: 'test' });
+      });
+
+      expect(mockSwitchTopic).toHaveBeenCalledWith('topic-id', true);
+    });
+
+    it('should not need to switch topic when active topic exists', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const mockSwitchTopic = vi.fn();
+
+      await act(async () => {
+        useChatStore.setState({
+          ...mockState,
+          switchTopic: mockSwitchTopic,
+        });
+        await result.current.sendMessage({ message: 'test' });
+      });
+
+      expect(mockSwitchTopic).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Cancel send message tests', () => {
+    it('should correctly cancel the current active send operation', () => {
+      const { result } = renderHook(() => useChatStore());
+      const mockAbort = vi.fn();
+      const mockSetJSONState = vi.fn();
+
+      act(() => {
+        useChatStore.setState({
+          activeId: 'session-1',
+          activeTopicId: 'topic-1',
+          mainSendMessageOperations: {
+            [messageMapKey('session-1', 'topic-1')]: {
+              isLoading: true,
+              abortController: { abort: mockAbort, signal: {} as any },
+              inputEditorTempState: { content: 'saved content' },
+            },
+          },
+          mainInputEditor: { setJSONState: mockSetJSONState } as any,
+        });
+      });
+
+      act(() => {
+        result.current.cancelSendMessageInServer();
+      });
+
+      expect(mockAbort).toHaveBeenCalledWith('User cancelled sendMessageInServer operation');
+      expect(
+        result.current.mainSendMessageOperations[messageMapKey('session-1', 'topic-1')]?.isLoading,
+      ).toBe(false);
+    });
+
+    it('should cancel the operation for the corresponding topic when topic ID is specified', () => {
+      const { result } = renderHook(() => useChatStore());
+      const mockAbort = vi.fn();
+
+      act(() => {
+        useChatStore.setState({
+          activeId: 'session-1',
+          mainSendMessageOperations: {
+            [messageMapKey('session-1', 'topic-2')]: {
+              isLoading: true,
+              abortController: { abort: mockAbort, signal: {} as any },
+            },
+          },
+        });
+      });
+
+      act(() => {
+        result.current.cancelSendMessageInServer('topic-2');
+      });
+
+      expect(mockAbort).toHaveBeenCalledWith('User cancelled sendMessageInServer operation');
+    });
+
+    it('should handle safely without throwing error when operation does not exist', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        useChatStore.setState({ mainSendMessageOperations: {} });
+      });
+
+      expect(() => {
+        act(() => {
+          result.current.cancelSendMessageInServer('non-existing-topic');
+        });
+      }).not.toThrow();
+    });
+  });
+
+  describe('Clear send error tests', () => {
+    it('should correctly clear error state for current topic', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        useChatStore.setState({
+          activeId: 'session-1',
+          activeTopicId: 'topic-1',
+          mainSendMessageOperations: {
+            [messageMapKey('session-1', 'topic-1')]: {
+              isLoading: false,
+              inputSendErrorMsg: 'Some error',
+            },
+          },
+        });
+      });
+
+      act(() => {
+        result.current.clearSendMessageError();
+      });
+
+      expect(
+        result.current.mainSendMessageOperations[messageMapKey('session-1', 'topic-1')],
+      ).toBeUndefined();
+    });
+
+    it('should handle safely when no error operation exists', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      act(() => {
+        useChatStore.setState({ mainSendMessageOperations: {} });
+      });
+
+      expect(() => {
+        act(() => {
+          result.current.clearSendMessageError();
+        });
+      }).not.toThrow();
+    });
+  });
+
+  describe('Operation state management tests', () => {
+    it('should correctly create new send operation', () => {
+      const { result } = renderHook(() => useChatStore());
+      let abortController: AbortController | undefined;
+
+      act(() => {
+        abortController = result.current.internal_toggleSendMessageOperation('test-key', true);
+      });
+
+      expect(abortController!).toBeInstanceOf(AbortController);
+      expect(result.current.mainSendMessageOperations['test-key']?.isLoading).toBe(true);
+      expect(result.current.mainSendMessageOperations['test-key']?.abortController).toBe(
+        abortController,
+      );
+    });
+
+    it('should correctly stop send operation', () => {
+      const { result } = renderHook(() => useChatStore());
+      const mockAbortController = { abort: vi.fn() } as any;
+
+      let abortController: AbortController | undefined;
+      act(() => {
+        result.current.internal_updateSendMessageOperation('test-key', {
+          isLoading: true,
+          abortController: mockAbortController,
+        });
+
+        abortController = result.current.internal_toggleSendMessageOperation('test-key', false);
+      });
+
+      expect(abortController).toBeUndefined();
+      expect(result.current.mainSendMessageOperations['test-key']?.isLoading).toBe(false);
+      expect(result.current.mainSendMessageOperations['test-key']?.abortController).toBeNull();
+    });
+
+    it('should correctly handle cancel reason and call abort method', () => {
+      const { result } = renderHook(() => useChatStore());
+      const mockAbortController = { abort: vi.fn() } as any;
+
+      result.current.internal_updateSendMessageOperation('test-key', {
+        isLoading: true,
+        abortController: mockAbortController,
+      });
+
+      result.current.internal_toggleSendMessageOperation('test-key', false, 'Test cancel reason');
+
+      expect(mockAbortController.abort).toHaveBeenCalledWith('Test cancel reason');
+    });
+
+    it('should support multiple parallel operations', () => {
+      const { result } = renderHook(() => useChatStore());
+
+      let abortController1, abortController2;
+      act(() => {
+        abortController1 = result.current.internal_toggleSendMessageOperation('pkey1', true);
+        abortController2 = result.current.internal_toggleSendMessageOperation('pkey2', true);
+      });
+
+      expect(result.current.mainSendMessageOperations['pkey1']?.isLoading).toBe(true);
+      expect(result.current.mainSendMessageOperations['pkey2']?.isLoading).toBe(true);
+      expect(abortController1).not.toBe(abortController2);
+    });
+  });
+
+  describe('Send operation state update tests', () => {
+    it('should correctly update operation state', () => {
+      const { result } = renderHook(() => useChatStore());
+      const mockAbortController = new AbortController();
+
+      act(() => {
+        result.current.internal_updateSendMessageOperation('abc', {
+          isLoading: true,
+          abortController: mockAbortController,
+          inputSendErrorMsg: 'test error',
+        });
+      });
+
+      expect(result.current.mainSendMessageOperations['abc']).toEqual({
+        isLoading: true,
+        abortController: mockAbortController,
+        inputSendErrorMsg: 'test error',
+      });
+    });
+
+    it('should support partial update of operation state', () => {
+      const { result } = renderHook(() => useChatStore());
+      const initialController = new AbortController();
+
+      act(() => {
+        result.current.internal_updateSendMessageOperation('test-key', {
+          isLoading: true,
+          abortController: initialController,
+        });
+
+        // Only update error message
+        result.current.internal_updateSendMessageOperation('test-key', {
+          inputSendErrorMsg: 'new error',
+        });
+      });
+
+      expect(result.current.mainSendMessageOperations['test-key']).toEqual({
+        isLoading: true,
+        abortController: initialController,
+        inputSendErrorMsg: 'new error',
+      });
+    });
+  });
+
+  describe('Editor state recovery tests', () => {
+    it('should restore editor content when cancelling operation', () => {
+      const { result } = renderHook(() => useChatStore());
+      const mockSetJSONState = vi.fn();
+      const mockAbort = vi.fn();
+
+      act(() => {
+        useChatStore.setState({
+          activeId: 'session-1',
+          activeTopicId: 'topic-1',
+          mainSendMessageOperations: {
+            [messageMapKey('session-1', 'topic-1')]: {
+              isLoading: true,
+              abortController: { abort: mockAbort, signal: {} as any },
+              inputEditorTempState: { content: 'saved content' },
+            },
+          },
+          mainInputEditor: { setJSONState: mockSetJSONState } as any,
+        });
+      });
+
+      act(() => {
+        result.current.cancelSendMessageInServer();
+      });
+
+      expect(mockSetJSONState).toHaveBeenCalledWith({ content: 'saved content' });
+    });
+
+    it('should not restore when no saved editor state exists', () => {
+      const { result } = renderHook(() => useChatStore());
+      const mockSetJSONState = vi.fn();
+      const mockAbort = vi.fn();
+
+      act(() => {
+        useChatStore.setState({
+          activeId: 'session-1',
+          activeTopicId: 'topic-1',
+          mainSendMessageOperations: {
+            [messageMapKey('session-1', 'topic-1')]: {
+              isLoading: true,
+              abortController: { abort: mockAbort, signal: {} as any },
+            },
+          },
+          mainInputEditor: { setJSONState: mockSetJSONState } as any,
+        });
+        result.current.cancelSendMessageInServer();
+      });
+
+      expect(mockSetJSONState).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/store/chat/slices/aiChat/actions/generateAIChatV2.ts

@@ -260,7 +260,8 @@ export const generateAIChatV2: StateCreator<
     // Only clear creating message state if it's the active session
     if (operationKey === messageMapKey(activeId, activeTopicId)) {
       const editorTempState = get().mainSendMessageOperations[operationKey]?.inputEditorTempState;
-      get().mainInputEditor?.setJSONState(editorTempState);
+
+      if (editorTempState) get().mainInputEditor?.setJSONState(editorTempState);
     }
   },
   clearSendMessageError: () => {