Feat: Use the message_id returned by the interface as the id of the reply message #3221 (#8434)

### What problem does this PR solve?
Feat: Use the message_id returned by the interface as the id of the
reply message #3221

### Type of change


- [x] New Feature (non-breaking change which adds functionality)

web/src/hooks/logic-hooks.ts

     [],
   );
 
+  const addNewestOneQuestion = useCallback((message: Message) => {
+    setDerivedMessages((pre) => {
+      return [
+        ...pre,
+        {
+          ...message,
+          id: buildMessageUuid(message), // The message id is generated on the front end,
+          // and the message id returned by the back end is the same as the question id,
+          //  so that the pair of messages can be deleted together when deleting the message
+        },
+      ];
+    });
+  }, []);
+
   // Add the streaming message to the last item in the message list
   const addNewestAnswer = useCallback((answer: IAnswer) => {
     setDerivedMessages((pre) => {
     });
   }, []);
 
+  // Add the streaming message to the last item in the message list
+  const addNewestOneAnswer = useCallback((answer: IAnswer) => {
+    setDerivedMessages((pre) => {
+      const idx = pre.findIndex((x) => x.id === answer.id);
+
+      if (idx !== -1) {
+        return pre.map((x) => {
+          if (x.id === answer.id) {
+            return { ...x, content: answer.answer };
+          }
+          return x;
+        });
+      }
+
+      return [
+        ...(pre ?? []),
+        {
+          role: MessageType.Assistant,
+          content: answer.answer,
+          reference: answer.reference,
+          id: buildMessageUuid({
+            id: answer.id,
+            role: MessageType.Assistant,
+          }),
+          prompt: answer.prompt,
+          audio_binary: answer.audio_binary,
+          ...omit(answer, 'reference'),
+        },
+      ];
+    });
+  }, []);
+
   const removeLatestMessage = useCallback(() => {
     setDerivedMessages((pre) => {
       const nextMessages = pre?.slice(0, -2) ?? [];
     addNewestAnswer,
     removeLatestMessage,
     removeMessageById,
+    addNewestOneQuestion,
+    addNewestOneAnswer,
     removeMessagesAfterCurrentMessage,
   };
 };

web/src/pages/agent/canvas/node/dropdown/next-step-dropdown.tsx

       <AccordionItem value="item-5">
         <AccordionTrigger className="text-xl">Tools</AccordionTrigger>
         <AccordionContent className="flex flex-col gap-4 text-balance">
-          <OperatorItemList operators={[Operator.Tavily]}></OperatorItemList>
+          <OperatorItemList
+            operators={[Operator.TavilySearch]}
+          ></OperatorItemList>
         </AccordionContent>
       </AccordionItem>
     </Accordion>

web/src/pages/agent/chat/hooks.ts

     removeLatestMessage,
     removeMessageById,
     removeMessagesAfterCurrentMessage,
+    addNewestOneQuestion,
+    addNewestOneAnswer,
   } = useSelectDerivedMessages();
 
   return {
     addNewestAnswer,
     removeLatestMessage,
     removeMessageById,
+    addNewestOneQuestion,
+    addNewestOneAnswer,
     removeMessagesAfterCurrentMessage,
   };
 };
     (x) => x.event === MessageEventType.Message,
   ) as IMessageEvent[];
   return {
-    id: messageEventList[0]?.message_id,
+    id: eventList[0]?.message_id,
     content: messageEventList.map((x) => x.data.content).join(''),
   };
 }
     addNewestAnswer,
     removeLatestMessage,
     removeMessageById,
+    addNewestOneQuestion,
+    addNewestOneAnswer,
   } = useSelectNextMessages();
   const { id: agentId } = useParams();
   const { handleInputChange, value, setValue } = useHandleMessageInputChange();
 
   useEffect(() => {
     const { content, id } = findMessageFromList(answerList);
-    if (content) {
-      addNewestAnswer({
+    if (answerList.length > 0) {
+      addNewestOneAnswer({
         answer: content,
         id: id,
       });
     }
-  }, [answerList, addNewestAnswer]);
+  }, [answerList, addNewestOneAnswer]);
 
   const handlePressEnter = useCallback(() => {
     if (trim(value) === '') return;
       setValue('');
       handleSendMessage({ id, content: value.trim(), role: MessageType.User });
     }
-    addNewestQuestion({
+    addNewestOneQuestion({
       content: value,
       id,
       role: MessageType.User,
     });
-  }, [addNewestQuestion, handleSendMessage, done, setValue, value]);
+  }, [value, done, addNewestOneQuestion, setValue, handleSendMessage]);
 
   useEffect(() => {
     if (prologue) {
-      addNewestAnswer({
+      addNewestOneAnswer({
         answer: prologue,
       });
     }
-  }, [addNewestAnswer, prologue]);
+  }, [addNewestOneAnswer, prologue]);
 
   useEffect(() => {
     addEventList(answerList);

web/src/pages/agent/constant.tsx

   WaitingDialogue = 'WaitingDialogue',
   Agent = 'Agent',
   Tool = 'Tool',
-  Tavily = 'Tavily',
+  TavilySearch = 'TavilySearch',
 }
 
 export const SwitchLogicOperatorOptions = ['and', 'or'];
   [Operator.Code]: { backgroundColor: '#4c5458' },
   [Operator.WaitingDialogue]: { backgroundColor: '#a5d65c' },
   [Operator.Agent]: { backgroundColor: '#a5d65c' },
-  [Operator.Tavily]: { backgroundColor: '#a5d65c' },
+  [Operator.TavilySearch]: { backgroundColor: '#a5d65c' },
 };
 
 export const componentMenuList = [
   [Operator.Code]: [Operator.Begin],
   [Operator.WaitingDialogue]: [Operator.Begin],
   [Operator.Agent]: [Operator.Begin],
+  [Operator.TavilySearch]: [Operator.Begin],
 };
 
 export const NodeMap = {
   [Operator.WaitingDialogue]: 'ragNode',
   [Operator.Agent]: 'agentNode',
   [Operator.Tool]: 'toolNode',
-  [Operator.Tavily]: 'ragNode',
+  [Operator.TavilySearch]: 'ragNode',
 };
 
 export const LanguageOptions = [

web/src/pages/agent/form-sheet/next.tsx

 
   const currentFormMap = FormConfigMap[operatorName];
 
-  const OperatorForm = currentFormMap.component ?? EmptyContent;
+  const OperatorForm = currentFormMap?.component ?? EmptyContent;
 
   const { name, handleNameBlur, handleNameChange } = useHandleNodeNameChange({
     id: node?.id,

web/src/pages/agent/form-sheet/use-form-config-map.tsx

       defaultValues: {},
       schema: z.object({}),
     },
-    [Operator.Tavily]: {
+    [Operator.TavilySearch]: {
       component: TavilyForm,
       defaultValues: {},
       schema: z.object({}),

web/src/pages/agent/form/agent-form/tool-popover/tool-command.tsx

   {
     label: 'Search',
     list: [
-      Operator.Tavily,
+      Operator.TavilySearch,
       Operator.Google,
       Operator.Bing,
       Operator.DuckDuckGo,

web/src/pages/agent/form/tool-form/constant.ts

   [Operator.YahooFinance]: YahooFinanceForm,
   [Operator.Crawler]: CrawlerForm,
   [Operator.Email]: EmailForm,
-  [Operator.Tavily]: TavilyForm,
+  [Operator.TavilySearch]: TavilyForm,
 };

web/src/pages/agent/hooks.tsx

       [Operator.Code]: initialCodeValues,
       [Operator.WaitingDialogue]: initialWaitingDialogueValues,
       [Operator.Agent]: { ...initialAgentValues, llm_id: llmId },
-      [Operator.Tavily]: initialTavilyValues,
+      [Operator.TavilySearch]: initialTavilyValues,
     };
   }, [llmId]);
 

web/src/pages/agent/hooks/use-add-node.ts

       [Operator.WaitingDialogue]: initialWaitingDialogueValues,
       [Operator.Agent]: { ...initialAgentValues, llm_id: llmId },
       [Operator.Tool]: {},
-      [Operator.Tavily]: initialTavilyValues,
+      [Operator.TavilySearch]: initialTavilyValues,
     };
   }, [llmId]);
 

web/src/pages/agent/utils.ts

   edges: Edge[],
   nodeId: string,
   isBuildDownstream = true,
+  nodes: Node[],
 ) => {
   return edges
-    .filter((y) => y[isBuildDownstream ? 'source' : 'target'] === nodeId)
+    .filter((y) => {
+      const node = nodes.find((x) => x.id === nodeId);
+      let isNotUpstreamTool = true;
+      if (isBuildDownstream && node?.data.label === Operator.Agent) {
+        isNotUpstreamTool = !y.target.startsWith(Operator.Tool); // Exclude the tool operator downstream of the agent operator
+      }
+      return (
+        y[isBuildDownstream ? 'source' : 'target'] === nodeId &&
+        isNotUpstreamTool
+      );
+    })
     .map((y) => y[isBuildDownstream ? 'target' : 'source']);
 };
 
     // initializeOperatorParams(operatorName), // Final processing, for guarantee
   );
 
+const ExcludeOperators = [Operator.Note, Operator.Tool];
+
 // construct a dsl based on the node information of the graph
 export const buildDslComponentsByGraph = (
   nodes: RAGFlowNodeType[],
   const components: DSLComponents = {};
 
   nodes
-    ?.filter((x) => x.data.label !== Operator.Note)
+    ?.filter((x) => !ExcludeOperators.some((y) => y === x.data.label))
     .forEach((x) => {
       const id = x.id;
       const operatorName = x.data.label;
               x.data.form as Record<string, unknown>,
             ) ?? {},
         },
-        downstream: buildComponentDownstreamOrUpstream(edges, id, true),
-        upstream: buildComponentDownstreamOrUpstream(edges, id, false),
+        downstream: buildComponentDownstreamOrUpstream(edges, id, true, nodes),
+        upstream: buildComponentDownstreamOrUpstream(edges, id, false, nodes),
         parent_id: x?.parentId,
       };
     });