@lobehub/chat 1.69.6 → 1.70.1

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[];