@lobehub/chat 1.69.5 → 1.70.0

package/src/hooks/useAgentEnableSearch.ts

@@ -9,19 +9,11 @@ export const useAgentEnableSearch = () => {
     agentChatConfigSelectors.agentSearchMode(s),
   ]);
 
-  const isModelSupportToolUse = useAiInfraStore(
-    aiModelSelectors.isModelSupportToolUse(model, provider),
-  );
   const searchImpl = useAiInfraStore(aiModelSelectors.modelBuiltinSearchImpl(model, provider));
 
   // 只要是内置的搜索实现，一定可以联网搜索
   if (searchImpl === 'internal') return true;
 
   // 如果是关闭状态，一定不能联网搜索
-  if (agentSearchMode === 'off') return false;
-
-  // 如果是智能模式，根据是否支持 Tool Calling 判断
-  if (agentSearchMode === 'auto') {
-    return isModelSupportToolUse;
-  }
+  return agentSearchMode !== 'off';
 };

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

@@ -102,7 +102,8 @@ export class LobeAnthropicAI implements LobeRuntimeAI {
 
     if (!!thinking) {
       const maxTokens =
-        max_tokens ?? (thinking?.budget_tokens ? thinking?.budget_tokens + 4096 : 4096);
+        // claude 3.7 thinking has max output of 64000 tokens
+        max_tokens ?? (thinking?.budget_tokens ? thinking?.budget_tokens + 64_000 : 8192);
 
       // `temperature` may only be set to 1 when thinking is enabled.
       // `top_p` must be unset when thinking is enabled.
@@ -117,7 +118,9 @@ export class LobeAnthropicAI implements LobeRuntimeAI {
     }
 
     return {
-      max_tokens: max_tokens ?? 4096,
+      // claude 3 series model hax max output token of 4096, 3.x series has 8192
+      // https://docs.anthropic.com/en/docs/about-claude/models/all-models#:~:text=200K-,Max%20output,-Normal%3A
+      max_tokens: max_tokens ?? (model.startsWith('claude-3-') ? 4096 : 8192),
       messages: postMessages,
       model,
       system: systemPrompts,

package/src/locales/default/chat.ts

@@ -65,6 +65,9 @@ export default {
     stop: '停止',
     warp: '换行',
   },
+  intentUnderstanding: {
+    title: '正在分析并理解意图您的意图...',
+  },
   knowledgeBase: {
     all: '所有内容',
     allFiles: '所有文件',
@@ -142,13 +145,11 @@ export default {
       searchQueries: '搜索关键词',
       title: '已搜索到 {{count}} 个结果',
     },
-
     mode: {
       auto: {
         desc: '根据对话内容智能判断是否需要搜索',
         title: '智能联网',
       },
-      disable: '当前模型不支持函数调用，因此无法使用智能联网功能',
       off: {
         desc: '仅使用模型的基础知识，不进行网络搜索',
         title: '关闭联网',
@@ -159,7 +160,10 @@ export default {
       },
       useModelBuiltin: '使用模型内置搜索引擎',
     },
-
+    searchModel: {
+      desc: '当前模型不支持函数调用，因此需要搭配支持函数调用的模型才能联网搜索',
+      title: '搜索辅助模型',
+    },
     title: '联网搜索',
   },
   searchAgentPlaceholder: '搜索助手...',

package/src/locales/default/components.ts

@@ -87,7 +87,9 @@ export default {
   },
   ModelSwitchPanel: {
     emptyModel: '没有启用的模型，请前往设置开启',
-    provider: '提供商',
+    emptyProvider: '没有启用的服务商，请前往设置开启',
+    goToSettings: '前往设置',
+    provider: '服务商',
   },
   OllamaSetupGuide: {
     cors: {

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

@@ -20,7 +20,14 @@ export const searchRouter = router({
       }),
     )
     .mutation(async ({ input }) => {
-      const crawler = new Crawler();
+      const envString = toolsEnv.CRAWLER_IMPLS || '';
+
+      // 处理全角逗号和多余空格
+      let envValue = envString.replaceAll('，', ',').trim();
+
+      const impls = envValue.split(',').filter(Boolean);
+
+      const crawler = new Crawler({ impls });
 
       const results = await pMap(
         input.urls,

package/src/services/__tests__/chat.test.ts

@@ -26,12 +26,16 @@ import {
   ModelProvider,
 } from '@/libs/agent-runtime';
 import { AgentRuntime } from '@/libs/agent-runtime';
+import { agentChatConfigSelectors } from '@/store/agent/selectors';
+import { aiModelSelectors } from '@/store/aiInfra';
 import { useToolStore } from '@/store/tool';
+import { toolSelectors } from '@/store/tool/selectors';
 import { UserStore } from '@/store/user';
 import { useUserStore } from '@/store/user';
 import { modelConfigSelectors } from '@/store/user/selectors';
 import { UserSettingsState, initialSettingsState } from '@/store/user/slices/settings/initialState';
 import { DalleManifest } from '@/tools/dalle';
+import { WebBrowsingManifest } from '@/tools/web-browsing';
 import { ChatMessage } from '@/types/message';
 import { ChatStreamPayload, type OpenAIChatMessage } from '@/types/openai/chat';
 import { LobeTool } from '@/types/tool';
@@ -480,6 +484,125 @@ describe('ChatService', () => {
         expect(calls![1]).toBeUndefined();
       });
     });
+
+    describe('search functionality', () => {
+      it('should add WebBrowsingManifest when search is enabled and not using model built-in search', async () => {
+        const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
+
+        const messages = [{ content: 'Search for something', role: 'user' }] as ChatMessage[];
+
+        // Mock agent store state with search enabled
+        vi.spyOn(agentChatConfigSelectors, 'currentChatConfig').mockReturnValueOnce({
+          searchMode: 'auto', // not 'off'
+          useModelBuiltinSearch: false,
+        } as any);
+
+        // Mock AI infra store state
+        vi.spyOn(aiModelSelectors, 'isModelHasBuiltinSearch').mockReturnValueOnce(() => false);
+        vi.spyOn(aiModelSelectors, 'isModelHasExtendParams').mockReturnValueOnce(() => false);
+
+        // Mock tool selectors
+        vi.spyOn(toolSelectors, 'enabledSchema').mockReturnValueOnce(() => [
+          {
+            type: 'function',
+            function: {
+              name: WebBrowsingManifest.identifier + '____search',
+              description: 'Search the web',
+            },
+          },
+        ]);
+
+        await chatService.createAssistantMessage({ messages, plugins: [] });
+
+        // Verify tools were passed to getChatCompletion
+        expect(getChatCompletionSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            tools: expect.arrayContaining([
+              expect.objectContaining({
+                function: expect.objectContaining({
+                  name: expect.stringContaining(WebBrowsingManifest.identifier),
+                }),
+              }),
+            ]),
+          }),
+          undefined,
+        );
+      });
+
+      it('should enable built-in search when model supports it and useModelBuiltinSearch is true', async () => {
+        const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
+
+        const messages = [{ content: 'Search for something', role: 'user' }] as ChatMessage[];
+
+        // Mock agent store state with search enabled and useModelBuiltinSearch enabled
+        vi.spyOn(agentChatConfigSelectors, 'currentChatConfig').mockReturnValueOnce({
+          searchMode: 'auto', // not 'off'
+          useModelBuiltinSearch: true,
+        } as any);
+
+        // Mock AI infra store state - model has built-in search
+        vi.spyOn(aiModelSelectors, 'isModelHasBuiltinSearch').mockReturnValueOnce(() => true);
+        vi.spyOn(aiModelSelectors, 'isModelHasExtendParams').mockReturnValueOnce(() => false);
+
+        // Mock tool selectors
+        vi.spyOn(toolSelectors, 'enabledSchema').mockReturnValueOnce(() => [
+          {
+            type: 'function',
+            function: {
+              name: WebBrowsingManifest.identifier + '____search',
+              description: 'Search the web',
+            },
+          },
+        ]);
+
+        await chatService.createAssistantMessage({ messages, plugins: [] });
+
+        // Verify enabledSearch was set to true
+        expect(getChatCompletionSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            enabledSearch: true,
+          }),
+          undefined,
+        );
+      });
+
+      it('should not enable search when searchMode is off', async () => {
+        const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
+
+        const messages = [{ content: 'Search for something', role: 'user' }] as ChatMessage[];
+
+        // Mock agent store state with search disabled
+        vi.spyOn(agentChatConfigSelectors, 'currentChatConfig').mockReturnValueOnce({
+          searchMode: 'off',
+          useModelBuiltinSearch: true,
+        } as any);
+
+        // Mock AI infra store state
+        vi.spyOn(aiModelSelectors, 'isModelHasBuiltinSearch').mockReturnValueOnce(() => true);
+        vi.spyOn(aiModelSelectors, 'isModelHasExtendParams').mockReturnValueOnce(() => false);
+
+        // Mock tool selectors
+        vi.spyOn(toolSelectors, 'enabledSchema').mockReturnValueOnce(() => [
+          {
+            type: 'function',
+            function: {
+              name: WebBrowsingManifest.identifier + '____search',
+              description: 'Search the web',
+            },
+          },
+        ]);
+
+        await chatService.createAssistantMessage({ messages, plugins: [] });
+
+        // Verify enabledSearch was not set
+        expect(getChatCompletionSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            enabledSearch: undefined,
+          }),
+          undefined,
+        );
+      });
+    });
   });
 
   describe('getChatCompletion', () => {
@@ -754,6 +877,7 @@ describe('ChatService', () => {
         // 重新模拟模块，设置 isServerMode 为 true
         vi.doMock('@/const/version', () => ({
           isServerMode: true,
+          isDeprecatedEdition: false,
         }));
 
         // 需要在修改模拟后重新导入相关模块

package/src/services/chat.ts

@@ -19,12 +19,7 @@ import { filesPrompts } from '@/prompts/files';
 import { BuiltinSystemRolePrompts } from '@/prompts/systemRole';
 import { getAgentStoreState } from '@/store/agent';
 import { agentChatConfigSelectors } from '@/store/agent/selectors';
-import {
-  aiModelSelectors,
-  aiProviderSelectors,
-  getAiInfraStoreState,
-  useAiInfraStore,
-} from '@/store/aiInfra';
+import { aiModelSelectors, aiProviderSelectors, getAiInfraStoreState } from '@/store/aiInfra';
 import { getSessionStoreState } from '@/store/session';
 import { sessionMetaSelectors } from '@/store/session/selectors';
 import { getToolStoreState } from '@/store/tool';
@@ -37,6 +32,7 @@ import {
   userProfileSelectors,
 } from '@/store/user/selectors';
 import { WebBrowsingManifest } from '@/tools/web-browsing';
+import { WorkingModel } from '@/types/agent';
 import { ChatErrorType } from '@/types/fetch';
 import { ChatMessage, MessageToolCall } from '@/types/message';
 import type { ChatStreamPayload, OpenAIChatMessage } from '@/types/openai/chat';
@@ -74,9 +70,9 @@ const findDeploymentName = (model: string, provider: string) => {
     if (deploymentName) deploymentId = deploymentName;
   } else {
     // find the model by id
-    const modelItem = useAiInfraStore
-      .getState()
-      .enabledAiModels?.find((i) => i.id === model && i.providerId === provider);
+    const modelItem = getAiInfraStoreState().enabledAiModels?.find(
+      (i) => i.id === model && i.providerId === provider,
+    );
 
     if (modelItem && modelItem.config?.deploymentName) {
       deploymentId = modelItem.config?.deploymentName;
@@ -91,7 +87,7 @@ const isEnableFetchOnClient = (provider: string) => {
   if (isDeprecatedEdition) {
     return modelConfigSelectors.isProviderFetchOnClient(provider)(useUserStore.getState());
   } else {
-    return aiProviderSelectors.isProviderFetchOnClient(provider)(useAiInfraStore.getState());
+    return aiProviderSelectors.isProviderFetchOnClient(provider)(getAiInfraStoreState());
   }
 };
 
@@ -181,10 +177,10 @@ class ChatService {
     const isModelHasBuiltinSearch = aiModelSelectors.isModelHasBuiltinSearch(
       payload.model,
       payload.provider!,
-    )(useAiInfraStore.getState());
+    )(getAiInfraStoreState());
 
-    const useApplicationBuiltinSearchTool =
-      enabledSearch && !(isModelHasBuiltinSearch && chatConfig.useModelBuiltinSearch);
+    const useModelSearch = isModelHasBuiltinSearch && chatConfig.useModelBuiltinSearch;
+    const useApplicationBuiltinSearchTool = enabledSearch && !useModelSearch;
 
     const pluginIds = [...(enabledPlugins || [])];
 
@@ -206,17 +202,10 @@ class ChatService {
 
     // ============  2. preprocess tools   ============ //
 
-    let filterTools = toolSelectors.enabledSchema(pluginIds)(getToolStoreState());
-
-    // check this model can use function call
-    const canUseFC = isCanUseFC(payload.model, payload.provider!);
-
-    // the rule that model can use tools:
-    // 1. tools is not empty
-    // 2. model can use function call
-    const shouldUseTools = filterTools.length > 0 && canUseFC;
-
-    const tools = shouldUseTools ? filterTools : undefined;
+    const tools = this.prepareTools(pluginIds, {
+      model: payload.model,
+      provider: payload.provider!,
+    });
 
     // ============  3. process extend params   ============ //
 
@@ -225,14 +214,14 @@ class ChatService {
     const isModelHasExtendParams = aiModelSelectors.isModelHasExtendParams(
       payload.model,
       payload.provider!,
-    )(useAiInfraStore.getState());
+    )(getAiInfraStoreState());
 
     // model
     if (isModelHasExtendParams) {
       const modelExtendParams = aiModelSelectors.modelExtendParams(
         payload.model,
         payload.provider!,
-      )(useAiInfraStore.getState());
+      )(getAiInfraStoreState());
       // if model has extended params, then we need to check if the model can use reasoning
 
       if (modelExtendParams!.includes('enableReasoning') && chatConfig.enableReasoning) {
@@ -241,13 +230,19 @@ class ChatService {
           type: 'enabled',
         };
       }
+      if (
+        modelExtendParams!.includes('disableContextCaching') &&
+        chatConfig.disableContextCaching
+      ) {
+        extendParams.enabledContextCaching = false;
+      }
     }
 
     return this.getChatCompletion(
       {
         ...params,
         ...extendParams,
-        enabledSearch: enabledSearch && isModelHasBuiltinSearch ? true : undefined,
+        enabledSearch: enabledSearch && useModelSearch ? true : undefined,
         messages: oaiMessages,
         tools,
       },
@@ -351,9 +346,8 @@ class ChatService {
 
     // TODO: remove `!isDeprecatedEdition` condition in V2.0
     if (!isDeprecatedEdition && !isBuiltin) {
-      const providerConfig = aiProviderSelectors.providerConfigById(provider)(
-        useAiInfraStore.getState(),
-      );
+      const providerConfig =
+        aiProviderSelectors.providerConfigById(provider)(getAiInfraStoreState());
 
       sdkType = providerConfig?.settings.sdkType || 'openai';
     }
@@ -433,16 +427,30 @@ class ChatService {
     onLoadingChange?.(true);
 
     try {
-      await this.getChatCompletion(params, {
-        onErrorHandle: (error) => {
-          errorHandle(new Error(error.message), error);
-        },
-        onFinish,
-        onMessageHandle,
-        signal: abortController?.signal,
-        trace: this.mapTrace(trace, TraceTagMap.SystemChain),
+      const oaiMessages = this.processMessages({
+        messages: params.messages as any,
+        model: params.model!,
+        provider: params.provider!,
+        tools: params.plugins,
+      });
+      const tools = this.prepareTools(params.plugins || [], {
+        model: params.model!,
+        provider: params.provider!,
       });
 
+      await this.getChatCompletion(
+        { ...params, messages: oaiMessages, tools },
+        {
+          onErrorHandle: (error) => {
+            errorHandle(new Error(error.message), error);
+          },
+          onFinish,
+          onMessageHandle,
+          signal: abortController?.signal,
+          trace: this.mapTrace(trace, TraceTagMap.SystemChain),
+        },
+      );
+
       onLoadingChange?.(false);
     } catch (e) {
       errorHandle(e as Error);
@@ -451,7 +459,7 @@ class ChatService {
 
   private processMessages = (
     {
-      messages,
+      messages = [],
       tools,
       model,
       provider,
@@ -483,6 +491,7 @@ class ChatService {
     };
 
     let postMessages = messages.map((m): OpenAIChatMessage => {
+      const supportTools = isCanUseFC(model, provider);
       switch (m.role) {
         case 'user': {
           return { content: getContent(m), role: m.role };
@@ -492,17 +501,23 @@ class ChatService {
           // signature is a signal of anthropic thinking mode
           const shouldIncludeThinking = m.reasoning && !!m.reasoning?.signature;
 
+          const content = shouldIncludeThinking
+            ? [
+                {
+                  signature: m.reasoning!.signature,
+                  thinking: m.reasoning!.content,
+                  type: 'thinking',
+                } as any,
+                { text: m.content, type: 'text' },
+              ]
+            : m.content;
+
+          if (!supportTools) {
+            return { content, role: m.role };
+          }
+
           return {
-            content: shouldIncludeThinking
-              ? [
-                  {
-                    signature: m.reasoning!.signature,
-                    thinking: m.reasoning!.content,
-                    type: 'thinking',
-                  } as any,
-                  { text: m.content, type: 'text' },
-                ]
-              : m.content,
+            content,
             role: m.role,
             tool_calls: m.tools?.map(
               (tool): MessageToolCall => ({
@@ -518,6 +533,10 @@ class ChatService {
         }
 
         case 'tool': {
+          if (!supportTools) {
+            return { content: m.content, role: 'user' };
+          }
+
           return {
             content: m.content,
             name: genToolCallingName(m.plugin!.identifier, m.plugin!.apiName, m.plugin?.type),
@@ -669,6 +688,20 @@ class ChatService {
 
     return reorderedMessages;
   };
+
+  private prepareTools = (pluginIds: string[], { model, provider }: WorkingModel) => {
+    let filterTools = toolSelectors.enabledSchema(pluginIds)(getToolStoreState());
+
+    // check this model can use function call
+    const canUseFC = isCanUseFC(model, provider!);
+
+    // the rule that model can use tools:
+    // 1. tools is not empty
+    // 2. model can use function call
+    const shouldUseTools = filterTools.length > 0 && canUseFC;
+
+    return shouldUseTools ? filterTools : undefined;
+  };
 }
 
 export const chatService = new ChatService();

package/src/services/session/type.ts

@@ -53,7 +53,7 @@ export interface ISessionService {
 
   updateSessionChatConfig(
     id: string,
-    config: DeepPartial<LobeAgentChatConfig>,
+    config: Partial<LobeAgentChatConfig>,
     signal?: AbortSignal,
   ): Promise<any>;
 

package/src/store/agent/slices/chat/selectors/__snapshots__/agent.test.ts.snap

@@ -11,6 +11,10 @@ exports[`agentSelectors > defaultAgentConfig > should merge DEFAULT_AGENT_CONFIG
     "enableReasoning": false,
     "historyCount": 8,
     "reasoningBudgetToken": 1024,
+    "searchFCModel": {
+      "model": "gpt-4o-mini",
+      "provider": "openai",
+    },
     "searchMode": "off",
   },
   "model": "gpt-3.5-turbo",

package/src/store/agent/slices/chat/selectors/chatConfig.ts

@@ -1,5 +1,5 @@
 import { contextCachingModels, thinkingWithToolClaudeModels } from '@/const/models';
-import { DEFAULT_AGENT_CHAT_CONFIG } from '@/const/settings';
+import { DEFAULT_AGENT_CHAT_CONFIG, DEFAULT_AGENT_SEARCH_FC_MODEL } from '@/const/settings';
 import { AgentStoreState } from '@/store/agent/initialState';
 import { LobeAgentChatConfig } from '@/types/agent';
 
@@ -14,6 +14,9 @@ const isAgentEnableSearch = (s: AgentStoreState) => agentSearchMode(s) !== 'off'
 const useModelBuiltinSearch = (s: AgentStoreState) =>
   currentAgentChatConfig(s).useModelBuiltinSearch;
 
+const searchFCModel = (s: AgentStoreState) =>
+  currentAgentChatConfig(s).searchFCModel || DEFAULT_AGENT_SEARCH_FC_MODEL;
+
 const enableHistoryCount = (s: AgentStoreState) => {
   const config = currentAgentConfig(s);
   const chatConfig = currentAgentChatConfig(s);
@@ -62,5 +65,6 @@ export const agentChatConfigSelectors = {
   enableHistoryDivider,
   historyCount,
   isAgentEnableSearch,
+  searchFCModel,
   useModelBuiltinSearch,
 };

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

@@ -765,10 +765,12 @@ describe('chatMessage actions', () => {
       (fetch as Mock).mockResolvedValueOnce(new Response(aiResponse));
 
       await act(async () => {
-        const response = await result.current.internal_fetchAIChatMessage(
+        const response = await result.current.internal_fetchAIChatMessage({
           messages,
-          assistantMessageId,
-        );
+          messageId: assistantMessageId,
+          model: 'gpt-4o-mini',
+          provider: 'openai',
+        });
         expect(response.isFunctionCall).toEqual(false);
       });
     });
@@ -784,7 +786,13 @@ describe('chatMessage actions', () => {
 
       await act(async () => {
         expect(
-          await result.current.internal_fetchAIChatMessage(messages, assistantMessageId),
+          await result.current.internal_fetchAIChatMessage({
+            model: 'gpt-4o-mini',
+            provider: 'openai',
+
+            messages,
+            messageId: assistantMessageId,
+          }),
         ).toEqual({
           isFunctionCall: false,
         });