Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

8.5 KB
Raw Blame
import { EmbedContainer } from '@/components/embed-container';
import { FileUploadProps } from '@/components/file-upload';
import { LoadingDots } from '@/components/loading-dots';
import { NextMessageInput } from '@/components/message-input/next';
import MessageItem from '@/components/next-message-item';
import PdfSheet from '@/components/pdf-drawer';
import { useClickDrawer } from '@/components/pdf-drawer/hooks';
import { RAGFlowAvatar } from '@/components/ragflow-avatar';
import SvgIcon from '@/components/svg-icon';
import { useSyncThemeFromParams } from '@/components/theme-provider';
import { VirtualMessageList } from '@/components/virtual-message-list';
import { MessageType } from '@/constants/chat';
import { useUploadAgentFileWithProgress } from '@/hooks/use-agent-request';
import { cn } from '@/lib/utils';
import i18n, { changeLanguageAsync } from '@/locales/config';
import DebugContent from '@/pages/agent/debug-content';
import { useCacheChatLog } from '@/pages/agent/hooks/use-cache-chat-log';
import { useAwaitComponentData } from '@/pages/agent/hooks/use-chat-logic';
import { isEmpty } from 'lodash';
import React, { forwardRef, useCallback } from 'react';
import {
  useGetSharedChatSearchParams,
  useSendButtonDisabled,
  useSendNextSharedMessage,
} from '../hooks/use-send-shared-message';
import { ParameterDialog } from './parameter-dialog';

const ChatContainer = () => {
  const {
    sharedId: conversationId,
    locale,
    theme,
    visibleAvatar,
  } = useGetSharedChatSearchParams();
  useSyncThemeFromParams(theme);
  const { visible, hideModal, documentId, selectedChunk, clickDocumentButton } =
    useClickDrawer();

  const { uploadAgentFile, loading } =
    useUploadAgentFileWithProgress(conversationId);
  const {
    addEventList,
    setCurrentMessageId,
    currentEventListWithoutMessageById,
    clearEventList,
  } = useCacheChatLog();

  const {
    handlePressEnter,
    handleInputChange,
    value,
    sendLoading,
    virtualizer,
    messageContainerRef,
    derivedMessages,
    hasError,
    inputsData,
    isTaskMode,
    stopOutputMessage,
    findReferenceByMessageId,
    appendUploadResponseList,
    parameterDialogVisible,
    showParameterDialog,
    sendFormMessage,
    addNewestOneAnswer,
    ok,
    resetSession,
  } = useSendNextSharedMessage(addEventList);

  const { buildInputList, handleOk, isWaiting } = useAwaitComponentData({
    derivedMessages,
    sendFormMessage,
  });
  const sendDisabled = useSendButtonDisabled(value);
  // The assistant message is only created when the first SSE frame arrives,
  // so fill the gap between sending and the first frame with a loading row.
  const showSendLoading =
    sendLoading && derivedMessages.at(-1)?.role !== MessageType.Assistant;

  const showBeginParameterDialog = useCallback(() => {
    if (inputsData && inputsData.inputs && !isEmpty(inputsData.inputs)) {
      showParameterDialog();
    }
  }, [inputsData, showParameterDialog]);

  const handleUploadFile: NonNullable<FileUploadProps['onUpload']> =
    useCallback(
      async (files, options) => {
        const ret = await uploadAgentFile({ files, options });
        appendUploadResponseList(ret.data, files);
      },
      [appendUploadResponseList, uploadAgentFile],
    );

  React.useEffect(() => {
    if (locale && i18n.language !== locale) {
      changeLanguageAsync(locale, { persist: false });
    }
  }, [locale, visibleAvatar]);

  React.useEffect(() => {
    if (!isTaskMode && inputsData.prologue) {
      addNewestOneAnswer({
        answer: inputsData.prologue,
      });
    }
  }, [inputsData.prologue, addNewestOneAnswer, isTaskMode]);

  React.useEffect(() => {
    showBeginParameterDialog();
  }, [showBeginParameterDialog]);

  const handleInputsModalOk = (params: any[]) => {
    ok(params);
  };
  const handleReset = () => {
    resetSession();
    clearEventList();
    showBeginParameterDialog();
  };
  if (!conversationId) {
    return <div>empty</div>;
  }

  return (
    <>
      <EmbedContainer
        title={inputsData.title}
        avatar={inputsData.avatar}
        handleReset={handleReset}
        hideReset={sendLoading}
      >
        <div className="flex flex-1 flex-col p-2.5  h-[90vh] m-3">
          <div
            className={cn(
              'flex flex-1 flex-col overflow-auto scrollbar-auto m-auto md:w-5/6',
            )}
            ref={messageContainerRef}
          >
            <VirtualMessageList
              className="w-full pr-6"
              items={derivedMessages}
              virtualizer={virtualizer}
              renderItem={(message, i) => (
                <MessageItem
                  visibleAvatar={visibleAvatar}
                  conversationId={conversationId}
                  currentEventListWithoutMessageById={
                    currentEventListWithoutMessageById
                  }
                  setCurrentMessageId={setCurrentMessageId}
                  item={message}
                  nickname="You"
                  reference={findReferenceByMessageId(message.id)}
                  loading={
                    message.role === MessageType.Assistant &&
                    sendLoading &&
                    derivedMessages?.length - 1 === i
                  }
                  isShare={true}
                  avatarDialog={inputsData.avatar}
                  agentName={inputsData.title}
                  index={i}
                  clickDocumentButton={clickDocumentButton}
                  showLikeButton={false}
                  showLoudspeaker={false}
                  showLog={false}
                  sendLoading={sendLoading}
                >
                  {message.role === MessageType.Assistant &&
                    derivedMessages.length - 1 === i && (
                      <DebugContent
                        parameters={buildInputList(message)}
                        message={message}
                        ok={handleOk(message)}
                        isNext={false}
                        btnText={'Submit'}
                      ></DebugContent>
                    )}
                  {message.role === MessageType.Assistant &&
                    derivedMessages.length - 1 !== i && (
                      <div>
                        <div>{message?.data?.tips}</div>

                        <div>
                          {buildInputList(message)?.map((item) => item.value)}
                        </div>
                      </div>
                    )}
                </MessageItem>
              )}
            />
            {showSendLoading && (
              <div className="flex w-full gap-5 py-6">
                {visibleAvatar &&
                  (inputsData.avatar || inputsData.title ? (
                    <RAGFlowAvatar
                      className="size-10"
                      avatar={inputsData.avatar}
                      name={inputsData.title}
                      isPerson
                    />
                  ) : (
                    <SvgIcon
                      name={'assistant'}
                      width={'100%'}
                      className="size-10 fill-current"
                    />
                  ))}
                <div className="px-2.5 py-1.5">
                  <LoadingDots className="text-text-secondary" />
                </div>
              </div>
            )}
          </div>
          {isTaskMode || (
            <div className="flex w-full justify-center md:mb-8">
              <div className="w-full md:w-5/6">
                <NextMessageInput
                  isShared
                  value={value}
                  disabled={hasError || isWaiting}
                  sendDisabled={sendDisabled || isWaiting}
                  resize="vertical"
                  conversationId={conversationId}
                  onInputChange={handleInputChange}
                  onPressEnter={handlePressEnter}
                  sendLoading={sendLoading}
                  stopOutputMessage={stopOutputMessage}
                  onUpload={handleUploadFile}
                  isUploading={loading || isWaiting}
                ></NextMessageInput>
              </div>
            </div>
          )}
        </div>
      </EmbedContainer>
      {visible && (
        <PdfSheet
          visible={visible}
          hideModal={hideModal}
          documentId={documentId}
          chunk={selectedChunk}
        ></PdfSheet>
      )}
      {parameterDialogVisible && (
        <ParameterDialog
          // hideModal={hideParameterDialog}
          ok={handleInputsModalOk}
          data={inputsData.inputs}
        ></ParameterDialog>
      )}
    </>
  );
};

export default forwardRef(ChatContainer);