@lobehub/chat 1.67.2 → 1.68.1

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

@@ -0,0 +1,51 @@
+import { ModelProvider } from '../types';
+import { LobeOpenAICompatibleFactory } from '../utils/openaiCompatibleFactory';
+import { PPIOModelCard } from './type';
+
+import type { ChatModelCard } from '@/types/llm';
+
+export const LobePPIOAI = LobeOpenAICompatibleFactory({
+  baseURL: 'https://api.ppinfra.com/v3/openai',
+  constructorOptions: {
+    defaultHeaders: {
+      'X-API-Source': 'lobechat',
+    },
+  },
+  debug: {
+    chatCompletion: () => process.env.DEBUG_PPIO_CHAT_COMPLETION === '1',
+  },
+  models: async ({ client }) => {
+    const { LOBE_DEFAULT_MODEL_LIST } = await import('@/config/aiModels');
+
+    const reasoningKeywords = [
+      'deepseek-r1',
+    ];
+
+    const modelsPage = await client.models.list() as any;
+    const modelList: PPIOModelCard[] = modelsPage.data;
+
+    return modelList
+      .map((model) => {
+        const knownModel = LOBE_DEFAULT_MODEL_LIST.find((m) => model.id.toLowerCase() === m.id.toLowerCase());
+
+        return {
+          contextWindowTokens: model.context_size,
+          description: model.description,
+          displayName: model.display_name?.replace("（", " (").replace("）", ")").replace("\t", "") || model.title || model.id,
+          enabled: knownModel?.enabled || false,
+          functionCall: knownModel?.abilities?.functionCall || false,
+          id: model.id,
+          reasoning:
+            reasoningKeywords.some(keyword => model.id.toLowerCase().includes(keyword))
+            || knownModel?.abilities?.reasoning
+            || false,
+          vision:
+            model.description.toLowerCase().includes('视觉')
+            || knownModel?.abilities?.vision
+            || false,
+        };
+      })
+      .filter(Boolean) as ChatModelCard[];
+  },
+  provider: ModelProvider.PPIO,
+});

package/src/libs/agent-runtime/ppio/type.ts

@@ -0,0 +1,12 @@
+export interface PPIOModelCard {
+  context_size: number;
+  created: number;
+  description: string;
+  display_name: string;
+  id: string;
+  input_token_price_per_m: number;
+  output_token_price_per_m: number;
+  status: number;
+  tags: string[];
+  title: string;
+}

package/src/libs/agent-runtime/types/type.ts

@@ -54,6 +54,7 @@ export enum ModelProvider {
   Ollama = 'ollama',
   OpenAI = 'openai',
   OpenRouter = 'openrouter',
+  PPIO = 'ppio',
   Perplexity = 'perplexity',
   Qwen = 'qwen',
   SambaNova = 'sambanova',

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/tools/web-browsing/Portal/PageContent/index.tsx

@@ -1,4 +1,4 @@
-import { Alert, CopyButton, Icon, Markdown } from '@lobehub/ui';
+import { Alert, CopyButton, Highlighter, Icon, Markdown } from '@lobehub/ui';
 import { Descriptions, Segmented, Typography } from 'antd';
 import { createStyles } from 'antd-style';
 import { ExternalLink } from 'lucide-react';
@@ -90,7 +90,42 @@ const PageContent = memo<PageContentProps>(({ result }) => {
   const { styles } = useStyles();
   const [display, setDisplay] = useState('render');
 
-  if (!result) return undefined;
+  if (!result || !result.data) return undefined;
+
+  if ('errorType' in result.data) {
+    return (
+      <Flexbox className={styles.footer} gap={4}>
+        <div>
+          <Descriptions
+            classNames={{
+              content: styles.footerText,
+            }}
+            column={1}
+            items={[
+              {
+                children: result.crawler,
+                label: t('search.crawPages.meta.crawler'),
+              },
+            ]}
+            size="small"
+          />
+        </div>
+        <Alert
+          extra={
+            <div style={{ maxWidth: 500, overflowX: 'scroll' }}>
+              <Highlighter language={'json'}>{JSON.stringify(result.data, null, 2)}</Highlighter>
+            </div>
+          }
+          message={
+            <div style={{ textAlign: 'start' }}>
+              {result.data.errorMessage || result.data.content}
+            </div>
+          }
+          type={'error'}
+        />
+      </Flexbox>
+    );
+  }
 
   const { url, title, description, content } = result.data;
   return (

package/src/tools/web-browsing/Render/PageContent/Result.tsx

@@ -1,7 +1,7 @@
 'use client';
 
-import { CrawlSuccessResult } from '@lobechat/web-crawler';
-import { Icon } from '@lobehub/ui';
+import { CrawlErrorResult, CrawlSuccessResult } from '@lobechat/web-crawler';
+import { Alert, Highlighter, Icon } from '@lobehub/ui';
 import { Descriptions, Typography } from 'antd';
 import { createStyles } from 'antd-style';
 import { ExternalLink } from 'lucide-react';
@@ -82,7 +82,7 @@ interface CrawlerData {
   crawler: string;
   messageId: string;
   originalUrl: string;
-  result: CrawlSuccessResult;
+  result: CrawlSuccessResult | CrawlErrorResult;
 }
 
 const CrawlerResultCard = memo<CrawlerData>(({ result, messageId, crawler, originalUrl }) => {
@@ -90,6 +90,39 @@ const CrawlerResultCard = memo<CrawlerData>(({ result, messageId, crawler, origi
   const { styles } = useStyles();
   const [openToolUI, togglePageContent] = useChatStore((s) => [s.openToolUI, s.togglePageContent]);
 
+  if ('errorType' in result) {
+    return (
+      <Flexbox className={styles.footer} gap={4}>
+        <div>
+          <Descriptions
+            classNames={{
+              content: styles.footerText,
+            }}
+            column={1}
+            items={[
+              {
+                children: crawler,
+                label: t('search.crawPages.meta.crawler'),
+              },
+            ]}
+            size="small"
+          />
+        </div>
+        <Alert
+          extra={
+            <div style={{ maxWidth: 500, overflowX: 'scroll' }}>
+              <Highlighter language={'json'}>{JSON.stringify(result, null, 2)}</Highlighter>
+            </div>
+          }
+          message={
+            <div style={{ textAlign: 'start' }}>{result.errorMessage || result.content}</div>
+          }
+          type={'error'}
+        />
+      </Flexbox>
+    );
+  }
+
   const { url, title, description } = result;
 
   return (

package/src/tools/web-browsing/Render/PageContent/index.tsx

@@ -1,3 +1,4 @@
+import { CrawlErrorResult } from '@lobechat/web-crawler';
 import { memo } from 'react';
 import { Flexbox } from 'react-layout-kit';
 
@@ -31,7 +32,16 @@ const PagesContent = memo<PagesContentProps>(({ results, messageId, urls }) => {
           key={result.originalUrl}
           messageId={messageId}
           originalUrl={result.originalUrl}
-          result={result.data}
+          result={
+            result.data ||
+            // TODO: Remove this in v2 as it's deprecated
+            ({
+              content: (result as any)?.content,
+              errorMessage: (result as any)?.errorMessage,
+              errorType: (result as any)?.errorType,
+              url: result.originalUrl,
+            } as CrawlErrorResult)
+          }
         />
       ))}
     </Flexbox>

package/src/types/tool/crawler.ts

@@ -1,4 +1,4 @@
-import { CrawlSuccessResult } from '@lobechat/web-crawler';
+import { CrawlErrorResult, CrawlSuccessResult } from '@lobechat/web-crawler';
 
 export interface CrawlSinglePageQuery {
   url: string;
@@ -10,7 +10,7 @@ export interface CrawlMultiPagesQuery {
 
 export interface CrawlResult {
   crawler: string;
-  data: CrawlSuccessResult;
+  data: CrawlSuccessResult | CrawlErrorResult;
   originalUrl: string;
 }
 

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;