@lobehub/chat 1.67.1 → 1.68.0

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

@@ -0,0 +1,264 @@
+ // @vitest-environment node
+import OpenAI from 'openai';
+import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { LobeOpenAICompatibleRuntime } from '@/libs/agent-runtime';
+import { ModelProvider } from '@/libs/agent-runtime';
+import { AgentRuntimeErrorType } from '@/libs/agent-runtime';
+
+import * as debugStreamModule from '../utils/debugStream';
+import models from './fixtures/models.json';
+import { LobePPIOAI } from './index';
+
+const provider = ModelProvider.PPIO;
+const defaultBaseURL = 'https://api.ppinfra.com/v3/openai';
+const bizErrorType = AgentRuntimeErrorType.ProviderBizError;
+const invalidErrorType = AgentRuntimeErrorType.InvalidProviderAPIKey;
+
+// Mock the console.error to avoid polluting test output
+vi.spyOn(console, 'error').mockImplementation(() => {});
+
+let instance: LobeOpenAICompatibleRuntime;
+
+beforeEach(() => {
+  instance = new LobePPIOAI({ apiKey: 'test' });
+
+  // 使用 vi.spyOn 来模拟 chat.completions.create 方法
+  vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+    new ReadableStream() as any,
+  );
+  vi.spyOn(instance['client'].models, 'list').mockResolvedValue({ data: [] } as any);
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('PPIO', () => {
+  describe('init', () => {
+    it('should correctly initialize with an API key', async () => {
+      const instance = new LobePPIOAI({ apiKey: 'test_api_key' });
+      expect(instance).toBeInstanceOf(LobePPIOAI);
+      expect(instance.baseURL).toEqual(defaultBaseURL);
+    });
+  });
+
+  describe('chat', () => {
+    describe('Error', () => {
+      it('should return Error with an openai error response when OpenAI.APIError is thrown', async () => {
+        // Arrange
+        const apiError = new OpenAI.APIError(
+          400,
+          {
+            status: 400,
+            error: {
+              message: 'Bad Request',
+            },
+          },
+          'Error message',
+          {},
+        );
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+
+        // Act
+        try {
+          await instance.chat({
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: 'meta-llama/llama-3-8b-instruct',
+            temperature: 0.999,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: defaultBaseURL,
+            error: {
+              error: { message: 'Bad Request' },
+              status: 400,
+            },
+            errorType: bizErrorType,
+            provider,
+          });
+        }
+      });
+
+      it('should throw AgentRuntimeError if no apiKey is provided', async () => {
+        try {
+          new LobePPIOAI({});
+        } catch (e) {
+          expect(e).toEqual({ errorType: invalidErrorType });
+        }
+      });
+
+      it('should return Error with the cause when OpenAI.APIError is thrown with cause', async () => {
+        // Arrange
+        const errorInfo = {
+          stack: 'abc',
+          cause: {
+            message: 'api is undefined',
+          },
+        };
+        const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+
+        // Act
+        try {
+          await instance.chat({
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: 'meta-llama/llama-3-8b-instruct',
+            temperature: 0.999,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: defaultBaseURL,
+            error: {
+              cause: { message: 'api is undefined' },
+              stack: 'abc',
+            },
+            errorType: bizErrorType,
+            provider,
+          });
+        }
+      });
+
+      it('should return Error with an cause response with desensitize Url', async () => {
+        // Arrange
+        const errorInfo = {
+          stack: 'abc',
+          cause: { message: 'api is undefined' },
+        };
+        const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
+
+        instance = new LobePPIOAI({
+          apiKey: 'test',
+
+          baseURL: 'https://api.abc.com/v1',
+        });
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(apiError);
+
+        // Act
+        try {
+          await instance.chat({
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: 'meta-llama/llama-3-8b-instruct',
+            temperature: 0.999,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: 'https://api.***.com/v1',
+            error: {
+              cause: { message: 'api is undefined' },
+              stack: 'abc',
+            },
+            errorType: bizErrorType,
+            provider,
+          });
+        }
+      });
+
+      it('should throw an error type on 401 status code', async () => {
+        // Mock the API call to simulate a 401 error
+        const error = new Error('InvalidApiKey') as any;
+        error.status = 401;
+        vi.mocked(instance['client'].chat.completions.create).mockRejectedValue(error);
+
+        try {
+          await instance.chat({
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: 'meta-llama/llama-3-8b-instruct',
+            temperature: 0.999,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: defaultBaseURL,
+            error: new Error('InvalidApiKey'),
+            errorType: invalidErrorType,
+            provider,
+          });
+        }
+      });
+
+      it('should return AgentRuntimeError for non-OpenAI errors', async () => {
+        // Arrange
+        const genericError = new Error('Generic Error');
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockRejectedValue(genericError);
+
+        // Act
+        try {
+          await instance.chat({
+            messages: [{ content: 'Hello', role: 'user' }],
+            model: 'meta-llama/llama-3-8b-instruct',
+            temperature: 0.999,
+          });
+        } catch (e) {
+          expect(e).toEqual({
+            endpoint: defaultBaseURL,
+            errorType: 'AgentRuntimeError',
+            provider,
+            error: {
+              name: genericError.name,
+              cause: genericError.cause,
+              message: genericError.message,
+              stack: genericError.stack,
+            },
+          });
+        }
+      });
+    });
+
+    describe('DEBUG', () => {
+      it('should call debugStream and return StreamingTextResponse when DEBUG_PPIO_CHAT_COMPLETION is 1', async () => {
+        // Arrange
+        const mockProdStream = new ReadableStream() as any; // 模拟的 prod 流
+        const mockDebugStream = new ReadableStream({
+          start(controller) {
+            controller.enqueue('Debug stream content');
+            controller.close();
+          },
+        }) as any;
+        mockDebugStream.toReadableStream = () => mockDebugStream; // 添加 toReadableStream 方法
+
+        // 模拟 chat.completions.create 返回值，包括模拟的 tee 方法
+        (instance['client'].chat.completions.create as Mock).mockResolvedValue({
+          tee: () => [mockProdStream, { toReadableStream: () => mockDebugStream }],
+        });
+
+        // 保存原始环境变量值
+        const originalDebugValue = process.env.DEBUG_PPIO_CHAT_COMPLETION;
+
+        // 模拟环境变量
+        process.env.DEBUG_PPIO_CHAT_COMPLETION = '1';
+        vi.spyOn(debugStreamModule, 'debugStream').mockImplementation(() => Promise.resolve());
+
+        // 执行测试
+        // 运行你的测试函数，确保它会在条件满足时调用 debugStream
+        // 假设的测试函数调用，你可能需要根据实际情况调整
+        await instance.chat({
+          messages: [{ content: 'Hello', role: 'user' }],
+          model: 'meta-llama/llama-3-8b-instruct',
+          stream: true,
+          temperature: 0.999,
+        });
+
+        // 验证 debugStream 被调用
+        expect(debugStreamModule.debugStream).toHaveBeenCalled();
+
+        // 恢复原始环境变量值
+        process.env.DEBUG_PPIO_CHAT_COMPLETION = originalDebugValue;
+      });
+    });
+  });
+
+  describe('models', () => {
+    it('should get models', async () => {
+      // mock the models.list method
+      (instance['client'].models.list as Mock).mockResolvedValue({ data: models });
+
+      const list = await instance.models();
+
+      expect(list).toMatchSnapshot();
+    });
+  });
+});

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/locales/default/plugin.ts

@@ -146,7 +146,7 @@ export default {
       detail: {
         preview: '预览',
         raw: '原始文本',
-        tooLong: '文本内容过长，对话上下文仅保留前 10000 字符，超过部分不计入会话上下文',
+        tooLong: '文本内容过长，对话上下文仅保留前 {{characters}} 字符，超过部分不计入会话上下文',
       },
       meta: {
         crawler: '抓取模式',

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/server/routers/tools/search.ts

@@ -15,7 +15,7 @@ export const searchRouter = router({
   crawlPages: searchProcedure
     .input(
       z.object({
-        impls: z.string().array().optional(),
+        impls: z.enum(['jina', 'naive', 'browserless']).array().optional(),
         urls: z.string().array(),
       }),
     )

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/chat/slices/builtinTool/actions/searXNG.ts

@@ -3,6 +3,7 @@ import { StateCreator } from 'zustand/vanilla';
 import { searchService } from '@/services/search';
 import { chatSelectors } from '@/store/chat/selectors';
 import { ChatStore } from '@/store/chat/store';
+import { CRAWL_CONTENT_LIMITED_COUNT } from '@/tools/web-browsing/const';
 import { CreateMessageParams } from '@/types/message';
 import {
   SEARCH_SEARXNG_NOT_CONFIG,
@@ -66,7 +67,7 @@ export const searchSlice: StateCreator<
             ...item.data,
             // if crawl too many content
             // slice the top 10000 char
-            content: item.data.content?.slice(0, 10_000),
+            content: item.data.content?.slice(0, CRAWL_CONTENT_LIMITED_COUNT),
           },
     );
 

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,