@lobehub/chat 1.67.2 → 1.68.0

package/src/libs/agent-runtime/utils/anthropicHelpers.ts

@@ -28,7 +28,7 @@ export const buildAnthropicBlock = async (
         return {
           source: {
             data: base64 as string,
-            media_type: mimeType as Anthropic.ImageBlockParam.Source['media_type'],
+            media_type: mimeType as Anthropic.Base64ImageSource['media_type'],
             type: 'base64',
           },
           type: 'image',
@@ -39,7 +39,7 @@ export const buildAnthropicBlock = async (
         return {
           source: {
             data: base64 as string,
-            media_type: mimeType as Anthropic.ImageBlockParam.Source['media_type'],
+            media_type: mimeType as Anthropic.Base64ImageSource['media_type'],
             type: 'base64',
           },
           type: 'image',

package/src/server/routers/tools/__test__/search.test.ts

@@ -0,0 +1,146 @@
+// @vitest-environment node
+import { TRPCError } from '@trpc/server';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { toolsEnv } from '@/config/tools';
+import { SearXNGClient } from '@/server/modules/SearXNG';
+import { SEARCH_SEARXNG_NOT_CONFIG } from '@/types/tool/search';
+
+import { searchRouter } from '../search';
+
+// Mock JWT verification
+vi.mock('@/utils/server/jwt', () => ({
+  getJWTPayload: vi.fn().mockResolvedValue({ userId: '1' }),
+}));
+
+vi.mock('@lobechat/web-crawler', () => ({
+  Crawler: vi.fn().mockImplementation(() => ({
+    crawl: vi.fn().mockResolvedValue({ content: 'test content' }),
+  })),
+}));
+
+vi.mock('@/server/modules/SearXNG');
+
+describe('searchRouter', () => {
+  const mockContext = {
+    req: {
+      headers: {
+        authorization: 'Bearer mock-token',
+      },
+    },
+    authorizationHeader: 'Bearer mock-token',
+    jwtPayload: { userId: '1' },
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // @ts-ignore
+    toolsEnv.SEARXNG_URL = 'http://test-searxng.com';
+  });
+
+  describe('crawlPages', () => {
+    it('should crawl multiple pages successfully', async () => {
+      const caller = searchRouter.createCaller(mockContext as any);
+
+      const result = await caller.crawlPages({
+        urls: ['http://test1.com', 'http://test2.com'],
+        impls: ['naive'],
+      });
+
+      expect(result.results).toHaveLength(2);
+      expect(result.results[0]).toEqual({ content: 'test content' });
+      expect(result.results[1]).toEqual({ content: 'test content' });
+    });
+
+    it('should work without specifying impls', async () => {
+      const caller = searchRouter.createCaller(mockContext as any);
+
+      const result = await caller.crawlPages({
+        urls: ['http://test.com'],
+      });
+
+      expect(result.results).toHaveLength(1);
+      expect(result.results[0]).toEqual({ content: 'test content' });
+    });
+  });
+
+  describe('query', () => {
+    it('should throw error if SEARXNG_URL is not configured', async () => {
+      // @ts-ignore
+      toolsEnv.SEARXNG_URL = undefined;
+
+      const caller = searchRouter.createCaller(mockContext as any);
+
+      await expect(
+        caller.query({
+          query: 'test query',
+        }),
+      ).rejects.toThrow(
+        new TRPCError({ code: 'NOT_IMPLEMENTED', message: SEARCH_SEARXNG_NOT_CONFIG }),
+      );
+    });
+
+    it('should return search results successfully', async () => {
+      const mockSearchResult = {
+        results: [
+          {
+            title: 'Test Result',
+            url: 'http://test.com',
+            content: 'Test content',
+          },
+        ],
+      };
+
+      (SearXNGClient as any).mockImplementation(() => ({
+        search: vi.fn().mockResolvedValue(mockSearchResult),
+      }));
+
+      const caller = searchRouter.createCaller(mockContext as any);
+
+      const result = await caller.query({
+        query: 'test query',
+        searchEngine: ['google'],
+      });
+
+      expect(result).toEqual(mockSearchResult);
+    });
+
+    it('should work without specifying search engines', async () => {
+      const mockSearchResult = {
+        results: [
+          {
+            title: 'Test Result',
+            url: 'http://test.com',
+            content: 'Test content',
+          },
+        ],
+      };
+
+      (SearXNGClient as any).mockImplementation(() => ({
+        search: vi.fn().mockResolvedValue(mockSearchResult),
+      }));
+
+      const caller = searchRouter.createCaller(mockContext as any);
+
+      const result = await caller.query({
+        query: 'test query',
+      });
+
+      expect(result).toEqual(mockSearchResult);
+    });
+
+    it('should handle search errors', async () => {
+      (SearXNGClient as any).mockImplementation(() => ({
+        search: vi.fn().mockRejectedValue(new Error('Search failed')),
+      }));
+
+      const caller = searchRouter.createCaller(mockContext as any);
+
+      await expect(
+        caller.query({
+          query: 'test query',
+        }),
+      ).rejects.toThrow(new TRPCError({ code: 'SERVICE_UNAVAILABLE', message: 'Search failed' }));
+    });
+  });
+});

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

@@ -4,6 +4,7 @@ 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 { CRAWL_CONTENT_LIMITED_COUNT } from '@/tools/web-browsing/const';
 import { ChatMessage } from '@/types/message';
 import { SearchContent, SearchQuery, SearchResponse } from '@/types/tool/search';
 
@@ -11,6 +12,7 @@ import { SearchContent, SearchQuery, SearchResponse } from '@/types/tool/search'
 vi.mock('@/services/search', () => ({
   searchService: {
     search: vi.fn(),
+    crawlPages: vi.fn(),
   },
 }));
 
@@ -181,6 +183,71 @@ describe('searXNG actions', () => {
     });
   });
 
+  describe('crawlMultiPages', () => {
+    it('should truncate content that exceeds limit', async () => {
+      const longContent = 'a'.repeat(CRAWL_CONTENT_LIMITED_COUNT + 1000);
+      const mockResponse = {
+        results: [
+          {
+            data: {
+              content: longContent,
+              title: 'Test Page',
+            },
+            crawler: 'naive',
+            originalUrl: 'https://test.com',
+          },
+        ],
+      };
+
+      (searchService.crawlPages as Mock).mockResolvedValue(mockResponse);
+
+      const { result } = renderHook(() => useChatStore());
+      const messageId = 'test-message-id';
+
+      await act(async () => {
+        await result.current.crawlMultiPages(messageId, { urls: ['https://test.com'] });
+      });
+
+      const expectedContent = [
+        {
+          content: longContent.slice(0, CRAWL_CONTENT_LIMITED_COUNT),
+          title: 'Test Page',
+        },
+      ];
+
+      expect(result.current.internal_updateMessageContent).toHaveBeenCalledWith(
+        messageId,
+        JSON.stringify(expectedContent),
+      );
+    });
+
+    it('should handle crawl errors', async () => {
+      const mockResponse = {
+        results: [
+          {
+            errorMessage: 'Failed to crawl',
+            errorType: 'CRAWL_ERROR',
+            originalUrl: 'https://test.com',
+          },
+        ],
+      };
+
+      (searchService.crawlPages as Mock).mockResolvedValue(mockResponse);
+
+      const { result } = renderHook(() => useChatStore());
+      const messageId = 'test-message-id';
+
+      await act(async () => {
+        await result.current.crawlMultiPages(messageId, { urls: ['https://test.com'] });
+      });
+
+      expect(result.current.internal_updateMessageContent).toHaveBeenCalledWith(
+        messageId,
+        JSON.stringify(mockResponse.results),
+      );
+    });
+  });
+
   describe('reSearchWithSearXNG', () => {
     it('should update arguments and perform search', async () => {
       const { result } = renderHook(() => useChatStore());

package/src/store/tool/slices/builtin/selectors.test.ts

@@ -41,6 +41,18 @@ describe('builtinToolSelectors', () => {
       ]);
     });
 
+    it('should hide tool when not need visible with hidden', () => {
+      const state = {
+        ...initialState,
+        builtinTools: [
+          { identifier: 'tool-1', hidden: true, manifest: { meta: { title: 'Tool 1' } } },
+          { identifier: DalleManifest.identifier, manifest: { meta: { title: 'Dalle' } } },
+        ],
+      } as ToolStoreState;
+      const result = builtinToolSelectors.metaList(false)(state);
+      expect(result).toEqual([]);
+    });
+
     it('should return an empty list if no builtin tools are available', () => {
       const state: ToolStoreState = {
         ...initialState,

package/src/store/tool/slices/builtin/selectors.ts

@@ -7,7 +7,10 @@ const metaList =
   (showDalle?: boolean) =>
   (s: ToolStoreState): LobeToolMeta[] =>
     s.builtinTools
-      .filter((item) => (!showDalle ? item.identifier !== DalleManifest.identifier : !item.hidden))
+      .filter(
+        (item) =>
+          !item.hidden && (!showDalle ? item.identifier !== DalleManifest.identifier : true),
+      )
       .map((t) => ({
         author: 'LobeHub',
         identifier: t.identifier,

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

@@ -65,6 +65,7 @@ export interface UserKeyVaults extends SearchEngineKeyVaults {
   openrouter?: OpenAICompatibleKeyVault;
   password?: string;
   perplexity?: OpenAICompatibleKeyVault;
+  ppio?: OpenAICompatibleKeyVault;
   qwen?: OpenAICompatibleKeyVault;
   sambanova?: OpenAICompatibleKeyVault;
   sensenova?: OpenAICompatibleKeyVault;