@lobehub/chat 1.69.6 → 1.70.0

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

@@ -877,6 +877,7 @@ describe('ChatService', () => {
         // 重新模拟模块，设置 isServerMode 为 true
         vi.doMock('@/const/version', () => ({
           isServerMode: true,
+          isDeprecatedEdition: false,
         }));
 
         // 需要在修改模拟后重新导入相关模块

package/src/services/chat.ts

@@ -32,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';
@@ -201,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   ============ //
 
@@ -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,
         });

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

@@ -13,10 +13,13 @@ import { messageService } from '@/services/message';
 import { useAgentStore } from '@/store/agent';
 import { agentChatConfigSelectors, agentSelectors } from '@/store/agent/selectors';
 import { getAgentStoreState } from '@/store/agent/store';
+import { aiModelSelectors } from '@/store/aiInfra';
+import { getAiInfraStoreState } from '@/store/aiInfra/store';
 import { chatHelpers } from '@/store/chat/helpers';
 import { ChatStore } from '@/store/chat/store';
 import { messageMapKey } from '@/store/chat/utils/messageMapKey';
 import { useSessionStore } from '@/store/session';
+import { WebBrowsingManifest } from '@/tools/web-browsing';
 import { ChatMessage, CreateMessageParams, SendMessageParams } from '@/types/message';
 import { MessageSemanticSearchChunk } from '@/types/rag';
 import { setNamespace } from '@/utils/storeDebug';
@@ -28,6 +31,7 @@ const n = setNamespace('ai');
 interface ProcessMessageParams {
   traceId?: string;
   isWelcomeQuestion?: boolean;
+  inSearchWorkflow?: boolean;
   /**
    * the RAG query content, should be embedding and used in the semantic search
    */
@@ -70,11 +74,13 @@ export interface AIGenerateAction {
   /**
    * Retrieves an AI-generated chat message from the backend service
    */
-  internal_fetchAIChatMessage: (
-    messages: ChatMessage[],
-    messageId: string,
-    params?: ProcessMessageParams,
-  ) => Promise<{
+  internal_fetchAIChatMessage: (input: {
+    messages: ChatMessage[];
+    messageId: string;
+    params?: ProcessMessageParams;
+    model: string;
+    provider: string;
+  }) => Promise<{
     isFunctionCall: boolean;
     traceId?: string;
   }>;
@@ -110,6 +116,8 @@ export interface AIGenerateAction {
     id?: string,
     action?: string,
   ) => AbortController | undefined;
+
+  internal_toggleSearchWorkflow: (loading: boolean, id?: string) => void;
 }
 
 export const generateAIChat: StateCreator<
@@ -336,10 +344,97 @@ export const generateAIChat: StateCreator<
 
     const assistantId = await get().internal_createMessage(assistantMessage);
 
-    // 3. fetch the AI response
-    const { isFunctionCall } = await internal_fetchAIChatMessage(messages, assistantId, params);
+    // 3. place a search with the search working model if this model is not support tool use
+    const isModelSupportToolUse = aiModelSelectors.isModelSupportToolUse(
+      model,
+      provider!,
+    )(getAiInfraStoreState());
+    const isAgentEnableSearch = agentChatConfigSelectors.isAgentEnableSearch(getAgentStoreState());
+
+    if (isAgentEnableSearch && !isModelSupportToolUse) {
+      const { model, provider } = agentChatConfigSelectors.searchFCModel(getAgentStoreState());
+
+      let isToolsCalling = false;
+      let isError = false;
+
+      const abortController = get().internal_toggleChatLoading(
+        true,
+        assistantId,
+        n('generateMessage(start)', { messageId: assistantId, messages }) as string,
+      );
+
+      get().internal_toggleSearchWorkflow(true, assistantId);
+      await chatService.fetchPresetTaskResult({
+        params: { messages, model, provider, plugins: [WebBrowsingManifest.identifier] },
+        onFinish: async (_, { toolCalls, usage }) => {
+          if (toolCalls && toolCalls.length > 0) {
+            get().internal_toggleToolCallingStreaming(assistantId, undefined);
+            // update tools calling
+            await get().internal_updateMessageContent(assistantId, '', {
+              toolCalls,
+              metadata: usage,
+              model,
+              provider,
+            });
+          }
+        },
+        abortController,
+        onMessageHandle: async (chunk) => {
+          if (chunk.type === 'tool_calls') {
+            get().internal_toggleSearchWorkflow(false, assistantId);
+            get().internal_toggleToolCallingStreaming(assistantId, chunk.isAnimationActives);
+            get().internal_dispatchMessage({
+              id: assistantId,
+              type: 'updateMessage',
+              value: { tools: get().internal_transformToolCalls(chunk.tool_calls) },
+            });
+            isToolsCalling = true;
+          }
+
+          if (chunk.type === 'text') {
+            abortController!.abort('not fc');
+          }
+        },
+        onErrorHandle: async (error) => {
+          isError = true;
+          await messageService.updateMessageError(assistantId, error);
+          await refreshMessages();
+        },
+      });
+
+      get().internal_toggleChatLoading(
+        false,
+        assistantId,
+        n('generateMessage(start)', { messageId: assistantId, messages }) as string,
+      );
+      get().internal_toggleSearchWorkflow(false, assistantId);
+
+      // if there is error, then stop
+      if (isError) return;
+
+      // if it's the function call message, trigger the function method
+      if (isToolsCalling) {
+        await refreshMessages();
+        await triggerToolCalls(assistantId, {
+          threadId: params?.threadId,
+          inPortalThread: params?.inPortalThread,
+        });
+
+        // then story the workflow
+        return;
+      }
+    }
+
+    // 4. fetch the AI response
+    const { isFunctionCall } = await internal_fetchAIChatMessage({
+      messages,
+      messageId: assistantId,
+      params,
+      model,
+      provider: provider!,
+    });
 
-    // 4. if it's the function call message, trigger the function method
+    // 5. if it's the function call message, trigger the function method
     if (isFunctionCall) {
       await refreshMessages();
       await triggerToolCalls(assistantId, {
@@ -348,7 +443,7 @@ export const generateAIChat: StateCreator<
       });
     }
 
-    // 5. summary history if context messages is larger than historyCount
+    // 6. summary history if context messages is larger than historyCount
     const historyCount = agentChatConfigSelectors.historyCount(getAgentStoreState());
 
     if (
@@ -365,7 +460,7 @@ export const generateAIChat: StateCreator<
       await get().internal_summaryHistory(historyMessages);
     }
   },
-  internal_fetchAIChatMessage: async (messages, messageId, params) => {
+  internal_fetchAIChatMessage: async ({ messages, messageId, params, provider, model }) => {
     const {
       internal_toggleChatLoading,
       refreshMessages,
@@ -382,7 +477,7 @@ export const generateAIChat: StateCreator<
     );
 
     const agentConfig = agentSelectors.currentAgentConfig(getAgentStoreState());
-    const chatConfig = agentConfig.chatConfig;
+    const chatConfig = agentChatConfigSelectors.currentChatConfig(getAgentStoreState());
 
     const compiler = template(chatConfig.inputTemplate, { interpolate: /{{([\S\s]+?)}}/g });
 
@@ -444,8 +539,8 @@ export const generateAIChat: StateCreator<
       abortController,
       params: {
         messages: preprocessMsgs,
-        model: agentConfig.model,
-        provider: agentConfig.provider,
+        model,
+        provider,
         ...agentConfig.params,
         plugins: agentConfig.plugins,
       },
@@ -529,6 +624,7 @@ export const generateAIChat: StateCreator<
             });
             break;
           }
+
           case 'reasoning': {
             // if there is no thinkingStartAt, it means the start of reasoning
             if (!thinkingStartAt) {
@@ -639,4 +735,8 @@ export const generateAIChat: StateCreator<
       `toggleToolCallingStreaming/${!!streaming ? 'start' : 'end'}`,
     );
   },
+
+  internal_toggleSearchWorkflow: (loading, id) => {
+    return get().internal_toggleLoadingArrays('searchWorkflowLoadingIds', loading, id);
+  },
 });

package/src/store/chat/slices/aiChat/initialState.ts

@@ -15,6 +15,7 @@ export interface ChatAIChatState {
    * is the AI message is reasoning
    */
   reasoningLoadingIds: string[];
+  searchWorkflowLoadingIds: string[];
   /**
    * the tool calling stream ids
    */
@@ -28,5 +29,6 @@ export const initialAiChatState: ChatAIChatState = {
   messageRAGLoadingIds: [],
   pluginApiLoadingIds: [],
   reasoningLoadingIds: [],
+  searchWorkflowLoadingIds: [],
   toolCallingStreamIds: {},
 };

package/src/store/chat/slices/aiChat/selectors.ts

@@ -1,9 +1,16 @@
-
 import type { ChatStoreState } from '../../initialState';
 
 const isMessageInReasoning = (id: string) => (s: ChatStoreState) =>
   s.reasoningLoadingIds.includes(id);
 
+const isMessageInSearchWorkflow = (id: string) => (s: ChatStoreState) =>
+  s.searchWorkflowLoadingIds.includes(id);
+
+const isIntentUnderstanding = (id: string) => (s: ChatStoreState) =>
+  isMessageInSearchWorkflow(id)(s);
+
 export const aiChatSelectors = {
+  isIntentUnderstanding,
   isMessageInReasoning,
+  isMessageInSearchWorkflow,
 };

package/src/store/chat/slices/message/action.ts

@@ -81,6 +81,8 @@ export interface ChatMessageAction {
       reasoning?: ModelReasoning;
       search?: GroundingSearch;
       metadata?: MessageMetadata;
+      model?: string;
+      provider?: string;
     },
   ) => Promise<void>;
   /**
@@ -302,7 +304,11 @@ export const chatMessage: StateCreator<
         value: { tools: internal_transformToolCalls(extra?.toolCalls) },
       });
     } else {
-      internal_dispatchMessage({ id, type: 'updateMessage', value: { content } });
+      internal_dispatchMessage({
+        id,
+        type: 'updateMessage',
+        value: { content },
+      });
     }
 
     await messageService.updateMessage(id, {
@@ -311,6 +317,8 @@ export const chatMessage: StateCreator<
       reasoning: extra?.reasoning,
       search: extra?.search,
       metadata: extra?.metadata,
+      model: extra?.model,
+      provider: extra?.provider,
     });
     await refreshMessages();
   },

package/src/store/chat/slices/plugin/action.ts

@@ -50,12 +50,13 @@ export interface ChatPluginAction {
     traceId?: string;
     threadId?: string;
     inPortalThread?: boolean;
+    inSearchWorkflow?: boolean;
   }) => Promise<void>;
   summaryPluginContent: (id: string) => Promise<void>;
 
   triggerToolCalls: (
     id: string,
-    params?: { threadId?: string; inPortalThread?: boolean },
+    params?: { threadId?: string; inPortalThread?: boolean; inSearchWorkflow?: boolean },
   ) => Promise<void>;
   updatePluginState: (id: string, value: any) => Promise<void>;
   updatePluginArguments: <T = any>(id: string, value: T) => Promise<void>;
@@ -209,7 +210,7 @@ export const chatPlugin: StateCreator<
     await get().internal_invokeDifferentTypePlugin(id, payload);
   },
 
-  triggerAIMessage: async ({ parentId, traceId, threadId, inPortalThread }) => {
+  triggerAIMessage: async ({ parentId, traceId, threadId, inPortalThread, inSearchWorkflow }) => {
     const { internal_coreProcessMessage } = get();
 
     const chats = inPortalThread
@@ -220,6 +221,7 @@ export const chatPlugin: StateCreator<
       traceId,
       threadId,
       inPortalThread,
+      inSearchWorkflow,
     });
   },
 
@@ -245,7 +247,7 @@ export const chatPlugin: StateCreator<
     );
   },
 
-  triggerToolCalls: async (assistantId, { threadId, inPortalThread } = {}) => {
+  triggerToolCalls: async (assistantId, { threadId, inPortalThread, inSearchWorkflow } = {}) => {
     const message = chatSelectors.getMessageById(assistantId)(get());
     if (!message || !message.tools) return;
 
@@ -281,7 +283,7 @@ export const chatPlugin: StateCreator<
 
     const traceId = chatSelectors.getTraceIdByMessageId(latestToolId)(get());
 
-    await get().triggerAIMessage({ traceId, threadId, inPortalThread });
+    await get().triggerAIMessage({ traceId, threadId, inPortalThread, inSearchWorkflow });
   },
   updatePluginState: async (id, value) => {
     const { refreshMessages } = get();

package/src/store/user/slices/settings/selectors/__snapshots__/settings.test.ts.snap

@@ -78,6 +78,10 @@ exports[`settingsSelectors > defaultAgent > should merge DEFAULT_AGENT and s.set
       "enableReasoning": false,
       "historyCount": 8,
       "reasoningBudgetToken": 1024,
+      "searchFCModel": {
+        "model": "gpt-4o-mini",
+        "provider": "openai",
+      },
       "searchMode": "off",
     },
     "model": "gpt-3.5-turbo",

package/src/types/agent/chatConfig.ts

@@ -62,5 +62,11 @@ export const AgentChatConfigSchema = z.object({
   enableReasoningEffort: z.boolean().optional(),
   historyCount: z.number().optional(),
   reasoningBudgetToken: z.number().optional(),
+  searchFCModel: z
+    .object({
+      model: z.string(),
+      provider: z.string(),
+    })
+    .optional(),
   searchMode: z.enum(['off', 'on', 'auto']).optional(),
 });

package/src/types/openai/chat.ts

@@ -68,7 +68,6 @@ export interface ChatStreamPayload {
    */
   n?: number;
   /**
-   * @deprecated
    * 开启的插件列表
    */
   plugins?: string[];