@lobehub/chat 1.64.2 → 1.65.0

package/src/store/chat/slices/builtinTool/actions/searXNG.test.ts

@@ -0,0 +1,288 @@
+import { act, renderHook } from '@testing-library/react';
+import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { searchService } from '@/services/search';
+import { useChatStore } from '@/store/chat';
+import { chatSelectors } from '@/store/chat/selectors';
+import { ChatMessage } from '@/types/message';
+import { SearchContent, SearchQuery, SearchResponse } from '@/types/tool/search';
+
+// Mock services
+vi.mock('@/services/search', () => ({
+  searchService: {
+    search: vi.fn(),
+  },
+}));
+
+vi.mock('@/store/chat/selectors', () => ({
+  chatSelectors: {
+    getMessageById: vi.fn(),
+  },
+}));
+
+describe('searXNG actions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    useChatStore.setState({
+      activeId: 'session-id',
+      activeTopicId: 'topic-id',
+      searchLoading: {},
+      internal_updateMessageContent: vi.fn(),
+      internal_updateMessagePluginError: vi.fn(),
+      updatePluginArguments: vi.fn(),
+      updatePluginState: vi.fn(),
+      internal_createMessage: vi.fn(),
+      internal_addToolToAssistantMessage: vi.fn(),
+      openToolUI: vi.fn(),
+    });
+  });
+
+  describe('searchWithSearXNG', () => {
+    it('should handle successful search', async () => {
+      const mockResponse: SearchResponse = {
+        results: [
+          {
+            title: 'Test Result',
+            content: 'Test Content',
+            url: 'https://test.com',
+            category: 'general',
+            engine: 'google',
+            engines: ['google'],
+            parsed_url: ['test.com'],
+            positions: [1],
+            score: 1,
+            template: 'default',
+          },
+        ],
+        answers: [],
+        corrections: [],
+        infoboxes: [],
+        number_of_results: 1,
+        query: 'test',
+        suggestions: [],
+        unresponsive_engines: [],
+      };
+
+      (searchService.search as Mock).mockResolvedValue(mockResponse);
+
+      const { result } = renderHook(() => useChatStore());
+      const { searchWithSearXNG } = result.current;
+
+      const messageId = 'test-message-id';
+      const query: SearchQuery = {
+        query: 'test query',
+        searchEngines: ['google'],
+      };
+
+      await act(async () => {
+        await searchWithSearXNG(messageId, query);
+      });
+
+      const expectedContent: SearchContent[] = [
+        {
+          content: 'Test Content',
+          title: 'Test Result',
+          url: 'https://test.com',
+        },
+      ];
+
+      expect(searchService.search).toHaveBeenCalledWith('test query', ['google']);
+      expect(result.current.searchLoading[messageId]).toBe(false);
+      expect(result.current.internal_updateMessageContent).toHaveBeenCalledWith(
+        messageId,
+        JSON.stringify(expectedContent),
+      );
+    });
+
+    it('should handle empty search results and retry with default engine', async () => {
+      const emptyResponse: SearchResponse = {
+        results: [],
+        answers: [],
+        corrections: [],
+        infoboxes: [],
+        number_of_results: 0,
+        query: 'test',
+        suggestions: [],
+        unresponsive_engines: [],
+      };
+
+      const retryResponse: SearchResponse = {
+        results: [
+          {
+            title: 'Retry Result',
+            content: 'Retry Content',
+            url: 'https://retry.com',
+            category: 'general',
+            engine: 'google',
+            engines: ['google'],
+            parsed_url: ['retry.com'],
+            positions: [1],
+            score: 1,
+            template: 'default',
+          },
+        ],
+        answers: [],
+        corrections: [],
+        infoboxes: [],
+        number_of_results: 1,
+        query: 'test',
+        suggestions: [],
+        unresponsive_engines: [],
+      };
+
+      (searchService.search as Mock)
+        .mockResolvedValueOnce(emptyResponse)
+        .mockResolvedValueOnce(retryResponse);
+
+      const { result } = renderHook(() => useChatStore());
+      const { searchWithSearXNG } = result.current;
+
+      const messageId = 'test-message-id';
+      const query: SearchQuery = {
+        query: 'test query',
+        searchEngines: ['custom-engine'],
+      };
+
+      await act(async () => {
+        await searchWithSearXNG(messageId, query);
+      });
+
+      expect(searchService.search).toHaveBeenCalledTimes(2);
+      expect(searchService.search).toHaveBeenNthCalledWith(1, 'test query', ['custom-engine']);
+      expect(searchService.search).toHaveBeenNthCalledWith(2, 'test query');
+      expect(result.current.updatePluginArguments).toHaveBeenCalledWith(messageId, {
+        query: 'test query',
+        searchEngines: undefined,
+      });
+    });
+
+    it('should handle search error', async () => {
+      const error = new Error('Search failed');
+      (searchService.search as Mock).mockRejectedValue(error);
+
+      const { result } = renderHook(() => useChatStore());
+      const { searchWithSearXNG } = result.current;
+
+      const messageId = 'test-message-id';
+      const query: SearchQuery = {
+        query: 'test query',
+      };
+
+      await act(async () => {
+        await searchWithSearXNG(messageId, query);
+      });
+
+      expect(result.current.internal_updateMessagePluginError).toHaveBeenCalledWith(messageId, {
+        body: error,
+        message: 'Search failed',
+        type: 'PluginServerError',
+      });
+      expect(result.current.searchLoading[messageId]).toBe(false);
+    });
+  });
+
+  describe('reSearchWithSearXNG', () => {
+    it('should update arguments and perform search', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const spy = vi.spyOn(result.current, 'searchWithSearXNG');
+      const { reSearchWithSearXNG } = result.current;
+
+      const messageId = 'test-message-id';
+      const query: SearchQuery = {
+        query: 'test query',
+      };
+
+      await act(async () => {
+        await reSearchWithSearXNG(messageId, query, { aiSummary: true });
+      });
+
+      expect(result.current.updatePluginArguments).toHaveBeenCalledWith(messageId, query);
+      expect(spy).toHaveBeenCalledWith(messageId, query, true);
+    });
+  });
+
+  describe('saveSearXNGSearchResult', () => {
+    it('should save search result as tool message', async () => {
+      const messageId = 'test-message-id';
+      const parentId = 'parent-message-id';
+      const mockMessage: Partial<ChatMessage> = {
+        id: messageId,
+        parentId,
+        content: 'test content',
+        plugin: {
+          identifier: 'search',
+          arguments: '{}',
+          apiName: 'search',
+          type: 'default',
+        },
+        pluginState: {},
+        role: 'assistant',
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        meta: {},
+      };
+
+      vi.spyOn(chatSelectors, 'getMessageById').mockImplementation(
+        () => () => mockMessage as ChatMessage,
+      );
+
+      const { result } = renderHook(() => useChatStore());
+      const { saveSearXNGSearchResult } = result.current;
+
+      await act(async () => {
+        await saveSearXNGSearchResult(messageId);
+      });
+
+      expect(result.current.internal_createMessage).toHaveBeenCalledWith(
+        expect.objectContaining({
+          content: 'test content',
+          parentId,
+          plugin: mockMessage.plugin,
+          pluginState: mockMessage.pluginState,
+          role: 'tool',
+        }),
+      );
+
+      expect(result.current.internal_addToolToAssistantMessage).toHaveBeenCalledWith(
+        parentId,
+        expect.objectContaining({
+          identifier: 'search',
+          type: 'default',
+        }),
+      );
+    });
+
+    it('should not save if message not found', async () => {
+      vi.spyOn(chatSelectors, 'getMessageById').mockImplementation(() => () => undefined);
+
+      const { result } = renderHook(() => useChatStore());
+      const { saveSearXNGSearchResult } = result.current;
+
+      await act(async () => {
+        await saveSearXNGSearchResult('non-existent-id');
+      });
+
+      expect(result.current.internal_createMessage).not.toHaveBeenCalled();
+      expect(result.current.internal_addToolToAssistantMessage).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('toggleSearchLoading', () => {
+    it('should toggle search loading state', () => {
+      const { result } = renderHook(() => useChatStore());
+      const messageId = 'test-message-id';
+
+      act(() => {
+        result.current.toggleSearchLoading(messageId, true);
+      });
+
+      expect(result.current.searchLoading[messageId]).toBe(true);
+
+      act(() => {
+        result.current.toggleSearchLoading(messageId, false);
+      });
+
+      expect(result.current.searchLoading[messageId]).toBe(false);
+    });
+  });
+});

package/src/store/user/slices/settings/selectors/__snapshots__/settings.test.ts.snap

@@ -75,7 +75,9 @@ exports[`settingsSelectors > defaultAgent > should merge DEFAULT_AGENT and s.set
       "enableAutoCreateTopic": true,
       "enableCompressHistory": true,
       "enableHistoryCount": true,
+      "enableReasoning": true,
       "historyCount": 8,
+      "reasoningBudgetToken": 1024,
       "searchMode": "off",
     },
     "model": "gpt-3.5-turbo",

package/src/types/agent/index.ts

@@ -55,33 +55,45 @@ export interface LobeAgentConfig {
   tts: LobeAgentTTSConfig;
 }
 
+/* eslint-disable sort-keys-fix/sort-keys-fix, typescript-sort-keys/interface */
+
 export interface LobeAgentChatConfig {
-  autoCreateTopicThreshold: number;
   displayMode?: 'chat' | 'docs';
+
   enableAutoCreateTopic?: boolean;
-  /**
-   * 历史消息长度压缩阈值
-   */
-  enableCompressHistory?: boolean;
-  /**
-   * 开启历史记录条数
-   */
-  enableHistoryCount?: boolean;
+  autoCreateTopicThreshold: number;
+
   enableMaxTokens?: boolean;
 
+  /**
+   * 是否开启推理
+   */
+  enableReasoning?: boolean;
   /**
    * 自定义推理强度
    */
   enableReasoningEffort?: boolean;
+  reasoningBudgetToken?: number;
 
   /**
    * 历史消息条数
    */
   historyCount?: number;
+  /**
+   * 开启历史记录条数
+   */
+  enableHistoryCount?: boolean;
+  /**
+   * 历史消息长度压缩阈值
+   */
+  enableCompressHistory?: boolean;
+
   inputTemplate?: string;
+
   searchMode?: SearchMode;
   useModelBuiltinSearch?: boolean;
 }
+/* eslint-enable */
 
 export const AgentChatConfigSchema = z.object({
   autoCreateTopicThreshold: z.number().default(2),
@@ -90,8 +102,10 @@ export const AgentChatConfigSchema = z.object({
   enableCompressHistory: z.boolean().optional(),
   enableHistoryCount: z.boolean().optional(),
   enableMaxTokens: z.boolean().optional(),
+  enableReasoning: z.boolean().optional(),
   enableReasoningEffort: z.boolean().optional(),
   historyCount: z.number().optional(),
+  reasoningBudgetToken: z.number().optional(),
   searchMode: z.enum(['off', 'on', 'auto']).optional(),
 });
 

package/src/types/aiModel.ts

@@ -138,17 +138,12 @@ export interface AiModelConfig {
   enabledSearch?: boolean;
 }
 
-export interface ExtendedControl {
-  key: string;
-  requestParams: string | string[];
-  type: 'params' | 'tool';
-  valueType: 'boolean';
-}
-
 export type ModelSearchImplementType = 'tool' | 'params' | 'internal';
 
+export type ExtendParamsType = 'reasoningBudgetToken' | 'enableReasoning';
+
 export interface AiModelSettings {
-  extendControls?: ExtendedControl[];
+  extendParams?: ExtendParamsType[];
   /**
    * 模型层实现搜索的方式
    */

package/src/features/ChatInput/ActionBar/Model/ExtendControls.tsx

@@ -1,40 +0,0 @@
-import { ActionIcon } from '@lobehub/ui';
-import { Popover } from 'antd';
-import { Settings2Icon } from 'lucide-react';
-import { memo } from 'react';
-import { useTranslation } from 'react-i18next';
-import { Flexbox } from 'react-layout-kit';
-
-import { useIsMobile } from '@/hooks/useIsMobile';
-
-import ControlsForm from './ControlsForm';
-
-const ExtendControls = memo(() => {
-  const { t } = useTranslation('chat');
-
-  const isMobile = useIsMobile();
-  return (
-    <Flexbox style={{ marginInlineStart: -4 }}>
-      <Popover
-        arrow={false}
-        content={<ControlsForm />}
-        open
-        styles={{
-          body: {
-            minWidth: isMobile ? undefined : 250,
-            width: isMobile ? '100vw' : undefined,
-          },
-        }}
-      >
-        <ActionIcon
-          icon={Settings2Icon}
-          placement={'bottom'}
-          style={{ borderRadius: 20 }}
-          title={t('extendControls.title')}
-        />
-      </Popover>
-    </Flexbox>
-  );
-});
-
-export default ExtendControls;