@lobehub/chat 1.64.1 → 1.64.3

package/src/config/aiModels/bedrock.ts

@@ -22,6 +22,26 @@ const bedrockChatModels: AIChatModelCard[] = [
       tokens: 32_000,
     },
 */
+  {
+    abilities: {
+      functionCall: true,
+      reasoning: true,
+      vision: true,
+    },
+    contextWindowTokens: 200_000,
+    description:
+      'Claude 3.7 sonnet 是 Anthropic 最快的下一代模型。与 Claude 3 Haiku 相比，Claude 3.7 Sonnet 在各项技能上都有所提升，并在许多智力基准测试中超越了上一代最大的模型 Claude 3 Opus。',
+    displayName: 'Claude 3.7 Sonnet',
+    enabled: true,
+    id: 'anthropic.claude-3-7-sonnet-20250219-v1:0',
+    maxOutput: 8192,
+    pricing: {
+      input: 3,
+      output: 15,
+    },
+    releasedAt: '2025-02-24',
+    type: 'chat',
+  },
   {
     abilities: {
       functionCall: true,
@@ -33,6 +53,7 @@ const bedrockChatModels: AIChatModelCard[] = [
     displayName: 'Claude 3.5 Sonnet',
     enabled: true,
     id: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
+    maxOutput: 8192,
     pricing: {
       input: 3,
       output: 15,
@@ -51,7 +72,7 @@ const bedrockChatModels: AIChatModelCard[] = [
     displayName: 'Claude 3.5 Sonnet v2 (Inference profile)',
     enabled: true,
     id: 'us.anthropic.claude-3-5-sonnet-20241022-v2:0',
-    maxOutput: 4096,
+    maxOutput: 8192,
     pricing: {
       input: 3,
       output: 15,
@@ -69,8 +90,8 @@ const bedrockChatModels: AIChatModelCard[] = [
       'Claude 3.5 Sonnet 提升了行业标准，性能超过竞争对手模型和 Claude 3 Opus，在广泛的评估中表现出色，同时具有我们中等层级模型的速度和成本。',
     displayName: 'Claude 3.5 Sonnet 0620',
     enabled: true,
-
     id: 'anthropic.claude-3-5-sonnet-20240620-v1:0',
+    maxOutput: 8192,
     pricing: {
       input: 3,
       output: 15,

package/src/config/modelProviders/anthropic.ts

@@ -3,6 +3,40 @@ import { ModelProviderCard } from '@/types/llm';
 // ref: https://docs.anthropic.com/en/docs/about-claude/models#model-names
 const Anthropic: ModelProviderCard = {
   chatModels: [
+    {
+      contextWindowTokens: 200_000,
+      description:
+        'Claude 3.7 sonnet 是 Anthropic 最快的下一代模型。与 Claude 3 Haiku 相比，Claude 3.7 Sonnet 在各项技能上都有所提升，并在许多智力基准测试中超越了上一代最大的模型 Claude 3 Opus。',
+      displayName: 'Claude 3.7 Sonnet',
+      enabled: true,
+      functionCall: true,
+      id: 'claude-3-7-sonnet-20250219',
+      maxOutput: 8192,
+      pricing: {
+        cachedInput: 0.1,
+        input: 1,
+        output: 5,
+        writeCacheInput: 1.25,
+      },
+      releasedAt: '2025-02-24',
+    },
+    {
+      contextWindowTokens: 200_000,
+      description:
+        'Claude 3.7 sonnet Extended thinking 是 Anthropic 最快的下一代模型。与 Claude 3 Haiku 相比，Claude 3.7 Sonnet 在各项技能上都有所提升，并在许多智力基准测试中超越了上一代最大的模型 Claude 3 Opus。',
+      displayName: 'Claude 3.7 Sonnet Extended thinking',
+      enabled: true,
+      functionCall: true,
+      id: 'claude-3-7-sonnet-20250219',
+      maxOutput: 64_000,
+      pricing: {
+        cachedInput: 0.1,
+        input: 1,
+        output: 5,
+        writeCacheInput: 1.25,
+      },
+      releasedAt: '2025-02-24',
+    },
     {
       contextWindowTokens: 200_000,
       description:

package/src/config/modelProviders/bedrock.ts

@@ -26,6 +26,57 @@ const Bedrock: ModelProviderCard = {
       tokens: 32_000,
     },
 */
+    {
+      contextWindowTokens: 200_000,
+      description:
+        'Claude 3.7 sonnet 是 Anthropic 最快的下一代模型。与 Claude 3 Haiku 相比，Claude 3.7 Sonnet 在各项技能上都有所提升，并在许多智力基准测试中超越了上一代最大的模型 Claude 3 Opus。',
+      displayName: 'Claude 3.7 Sonnet',
+      enabled: true,
+      functionCall: true,
+      id: 'anthropic.claude-3-7-sonnet-20250219-v1:0',
+      maxOutput: 8192,
+      pricing: {
+        cachedInput: 0.1,
+        input: 1,
+        output: 5,
+        writeCacheInput: 1.25,
+      },
+      releasedAt: '2025-02-24',
+    },
+    {
+      contextWindowTokens: 200_000,
+      description:
+        'Claude 3.7 sonnet Extended thinking 是 Anthropic 最快的下一代模型。与 Claude 3 Haiku 相比，Claude 3.7 Sonnet 在各项技能上都有所提升，并在许多智力基准测试中超越了上一代最大的模型 Claude 3 Opus。',
+      displayName: 'Claude 3.7 Sonnet Extended thinking',
+      enabled: true,
+      functionCall: true,
+      id: 'anthropic.claude-3-7-sonnet-20250219-v1:0',
+      maxOutput: 64_000,
+      pricing: {
+        cachedInput: 0.1,
+        input: 1,
+        output: 5,
+        writeCacheInput: 1.25,
+      },
+      releasedAt: '2025-02-24',
+    },
+    {
+      contextWindowTokens: 200_000,
+      description:
+        'Claude 3.5 Haiku 是 Anthropic 最快的下一代模型。与 Claude 3 Haiku 相比，Claude 3.5 Haiku 在各项技能上都有所提升，并在许多智力基准测试中超越了上一代最大的模型 Claude 3 Opus。',
+      displayName: 'Claude 3.5 Haiku',
+      enabled: true,
+      functionCall: true,
+      id: 'anthropic.claude-3-5-haiku-20241022-v1:0',
+      maxOutput: 8192,
+      pricing: {
+        cachedInput: 0.1,
+        input: 1,
+        output: 5,
+        writeCacheInput: 1.25,
+      },
+      releasedAt: '2024-11-05',
+    },
     {
       contextWindowTokens: 200_000,
       description:

package/src/features/Conversation/Messages/Assistant/Tool/Render/CustomRender.tsx

@@ -38,6 +38,7 @@ const CustomRender = memo<
     const { t } = useTranslation('plugin');
 
     const theme = useTheme();
+
     useEffect(() => {
       if (!plugin?.type || loading) return;
 

package/src/features/Conversation/Messages/Assistant/Tool/Render/index.tsx

@@ -1,5 +1,6 @@
 import { Suspense, memo } from 'react';
 
+import { LOADING_FLAT } from '@/const/message';
 import ErrorResponse from '@/features/Conversation/Messages/Assistant/Tool/Render/ErrorResponse';
 import { useChatStore } from '@/store/chat';
 import { chatSelectors } from '@/store/chat/selectors';
@@ -28,6 +29,11 @@ const Render = memo<RenderProps>(
         return <ErrorResponse {...toolMessage.error} id={messageId} plugin={toolMessage.plugin} />;
       }
 
+      // 如果是 LOADING_FLAT 则说明还在加载中
+      // 而 standalone 模式的插件 content 应该始终是 LOADING_FLAT
+      if (toolMessage.content === LOADING_FLAT && toolMessage.plugin?.type !== 'standalone')
+        return <Arguments arguments={requestArgs} shine />;
+
       return (
         <Suspense fallback={<Arguments arguments={requestArgs} shine />}>
           <CustomRender

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

@@ -626,7 +626,7 @@ export const generateAIChat: StateCreator<
       },
 
       false,
-      'toggleToolCallingStreaming',
+      `toggleToolCallingStreaming/${!!streaming ? 'start' : 'end'}`,
     );
   },
 });

package/src/store/chat/slices/builtinTool/{action.test.ts → actions/dalle.test.ts}

@@ -10,9 +10,9 @@ import { chatSelectors } from '@/store/chat/selectors';
 import { ChatMessage } from '@/types/message';
 import { DallEImageItem } from '@/types/tool/dalle';
 
-import { useChatStore } from '../../store';
+import { useChatStore } from '../../../store';
 
-describe('chatToolSlice', () => {
+describe('chatToolSlice - dalle', () => {
   describe('generateImageFromPrompts', () => {
     it('should generate images from prompts, update items, and upload images', async () => {
       const { result } = renderHook(() => useChatStore());

package/src/store/chat/slices/builtinTool/actions/dalle.ts

@@ -0,0 +1,126 @@
+import { produce } from 'immer';
+import pMap from 'p-map';
+import { SWRResponse } from 'swr';
+import { StateCreator } from 'zustand/vanilla';
+
+import { useClientDataSWR } from '@/libs/swr';
+import { fileService } from '@/services/file';
+import { imageGenerationService } from '@/services/textToImage';
+import { uploadService } from '@/services/upload';
+import { chatSelectors } from '@/store/chat/selectors';
+import { ChatStore } from '@/store/chat/store';
+import { useFileStore } from '@/store/file';
+import { DallEImageItem } from '@/types/tool/dalle';
+
+
+import { setNamespace } from '@/utils/storeDebug';
+
+const n = setNamespace('tool');
+
+const SWR_FETCH_KEY = 'FetchImageItem';
+
+export interface ChatDallEAction {
+  generateImageFromPrompts: (items: DallEImageItem[], id: string) => Promise<void>;
+  text2image: (id: string, data: DallEImageItem[]) => Promise<void>;
+  toggleDallEImageLoading: (key: string, value: boolean) => void;
+  updateImageItem: (id: string, updater: (data: DallEImageItem[]) => void) => Promise<void>;
+  useFetchDalleImageItem: (id: string) => SWRResponse;
+}
+
+export const dalleSlice: StateCreator<
+  ChatStore,
+  [['zustand/devtools', never]],
+  [],
+  ChatDallEAction
+> = (set, get) => ({
+  generateImageFromPrompts: async (items, messageId) => {
+    const { toggleDallEImageLoading, updateImageItem } = get();
+    // eslint-disable-next-line unicorn/consistent-function-scoping
+    const getMessageById = (id: string) => chatSelectors.getMessageById(id)(get());
+
+    const message = getMessageById(messageId);
+    if (!message) return;
+
+    const parent = getMessageById(message!.parentId!);
+    const originPrompt = parent?.content;
+    let errorArray: any[] = [];
+
+    await pMap(items, async (params, index) => {
+      toggleDallEImageLoading(messageId + params.prompt, true);
+
+      let url = '';
+      try {
+        url = await imageGenerationService.generateImage(params);
+      } catch (e) {
+        toggleDallEImageLoading(messageId + params.prompt, false);
+        errorArray[index] = e;
+
+        await get().updatePluginState(messageId, { error: errorArray });
+      }
+
+      if (!url) return;
+
+      await updateImageItem(messageId, (draft) => {
+        draft[index].previewUrl = url;
+      });
+
+      toggleDallEImageLoading(messageId + params.prompt, false);
+      const imageFile = await uploadService.getImageFileByUrlWithCORS(
+        url,
+        `${originPrompt || params.prompt}_${index}.png`,
+      );
+
+      const data = await useFileStore.getState().uploadWithProgress({
+        file: imageFile,
+      });
+
+      if (!data) return;
+
+      await updateImageItem(messageId, (draft) => {
+        draft[index].imageId = data.id;
+        draft[index].previewUrl = undefined;
+      });
+    });
+  },
+  text2image: async (id, data) => {
+    // const isAutoGen = settingsSelectors.isDalleAutoGenerating(useGlobalStore.getState());
+    // if (!isAutoGen) return;
+
+    await get().generateImageFromPrompts(data, id);
+  },
+
+  toggleDallEImageLoading: (key, value) => {
+    set(
+      { dalleImageLoading: { ...get().dalleImageLoading, [key]: value } },
+      false,
+      n('toggleDallEImageLoading'),
+    );
+  },
+
+  updateImageItem: async (id, updater) => {
+    const message = chatSelectors.getMessageById(id)(get());
+    if (!message) return;
+
+    const data: DallEImageItem[] = JSON.parse(message.content);
+
+    const nextContent = produce(data, updater);
+    await get().internal_updateMessageContent(id, JSON.stringify(nextContent));
+  },
+
+  useFetchDalleImageItem: (id) =>
+    useClientDataSWR([SWR_FETCH_KEY, id], async () => {
+      const item = await fileService.getFile(id);
+
+      set(
+        produce((draft) => {
+          if (draft.dalleImageMap[id]) return;
+
+          draft.dalleImageMap[id] = item;
+        }),
+        false,
+        n('useFetchFile'),
+      );
+
+      return item;
+    }),
+});

package/src/store/chat/slices/builtinTool/actions/index.ts

@@ -0,0 +1,18 @@
+import { StateCreator } from 'zustand/vanilla';
+
+import { ChatStore } from '@/store/chat/store';
+
+import { ChatDallEAction, dalleSlice } from './dalle';
+import { SearchAction, searchSlice } from './searXNG';
+
+export interface ChatBuiltinToolAction extends ChatDallEAction, SearchAction {}
+
+export const chatToolSlice: StateCreator<
+  ChatStore,
+  [['zustand/devtools', never]],
+  [],
+  ChatBuiltinToolAction
+> = (...params) => ({
+  ...dalleSlice(...params),
+  ...searchSlice(...params),
+});

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);
+    });
+  });
+});