LibreChat/client/src/hooks/SSE/useContentHandler.ts
Danny Avila 98b437edd5
🖱️ fix: Message Scrolling UX; refactor: Frontend UX/DX Optimizations (#3733)
* refactor(DropdownPopup): set MenuButton `as` prop to `div` to prevent React warning: validateDOMNesting(...): <button> cannot appear as a descendant of <button>

* refactor: memoize ChatGroupItem and ControlCombobox components

* refactor(OpenAIClient): await stream process finish before finalCompletion event handling

* refactor: update useSSE.ts typing to handle null and undefined values in data properties

* refactor: set abort scroll to false on SSE connection open

* refactor: improve logger functionality with filter support

* refactor: update handleScroll typing in MessageContainer component

* refactor: update logger.dir call in useChatFunctions to log 'message_stream' tag format instead of the entire submission object as first arg

* refactor: fix null check for message object in Message component

* refactor: throttle handleScroll to help prevent auto-scrolling issues on new message requests; fix type issues within useMessageProcess

* refactor: add abortScrollByIndex logging effect

* refactor: update MessageIcon and Icon components to use React.memo for performance optimization

* refactor: memoize ConvoIconURL component for performance optimization

* chore: type issues

* chore: update package version to 0.7.414
2024-08-21 18:18:45 -04:00

83 lines
2.6 KiB
TypeScript

import { useCallback, useMemo } from 'react';
import { ContentTypes } from 'librechat-data-provider';
import { useQueryClient } from '@tanstack/react-query';
import type {
Text,
TMessage,
ImageFile,
ContentPart,
PartMetadata,
TContentData,
EventSubmission,
TMessageContentParts,
} from 'librechat-data-provider';
import { addFileToCache } from '~/utils';
type TUseContentHandler = {
setMessages: (messages: TMessage[]) => void;
getMessages: () => TMessage[] | undefined;
};
type TContentHandler = {
data: TContentData;
submission: EventSubmission;
};
export default function useContentHandler({ setMessages, getMessages }: TUseContentHandler) {
const queryClient = useQueryClient();
const messageMap = useMemo(() => new Map<string, TMessage>(), []);
return useCallback(
({ data, submission }: TContentHandler) => {
const { type, messageId, thread_id, conversationId, index } = data;
const _messages = getMessages();
const messages =
_messages
?.filter((m) => m.messageId !== messageId)
?.map((msg) => ({ ...msg, thread_id })) ?? [];
const userMessage = messages[messages.length - 1] as TMessage | undefined;
const { initialResponse } = submission;
let response = messageMap.get(messageId);
if (!response) {
response = {
...(initialResponse as TMessage),
parentMessageId: userMessage?.messageId ?? '',
conversationId,
messageId,
thread_id,
};
messageMap.set(messageId, response);
}
// TODO: handle streaming for non-text
const textPart: Text | string | undefined = data[ContentTypes.TEXT];
const part: ContentPart =
textPart != null && typeof textPart === 'string' ? { value: textPart } : data[type];
if (type === ContentTypes.IMAGE_FILE) {
addFileToCache(queryClient, part as ImageFile & PartMetadata);
}
/* spreading the content array to avoid mutation */
response.content = [...(response.content ?? [])];
response.content[index] = { type, [type]: part } as TMessageContentParts;
if (
type !== ContentTypes.TEXT &&
initialResponse.content &&
((response.content[response.content.length - 1].type === ContentTypes.TOOL_CALL &&
response.content[response.content.length - 1][ContentTypes.TOOL_CALL].progress === 1) ||
response.content[response.content.length - 1].type === ContentTypes.IMAGE_FILE)
) {
response.content.push(initialResponse.content[0]);
}
setMessages([...messages, response]);
},
[queryClient, getMessages, messageMap, setMessages],
);
}