RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
/*
* Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import CopyToClipboard from '@/components/copy-to-clipboard';
import PdfSheet from '@/components/pdf-drawer';
import { useClickDrawer } from '@/components/pdf-drawer/hooks';
import { Modal } from '@/components/ui/modal/modal';
import { Spin } from '@/components/ui/spin';
import { MessageType, SharedFrom } from '@/constants/chat';
import { useFetchExternalAgentInputs } from '@/hooks/use-agent-request';
import { useFetchExternalChatInfo } from '@/hooks/use-chat-request';
import { IMessage } from '@/interfaces/database/chat';
import i18n, { changeLanguageAsync } from '@/locales/config';
import DebugContent from '@/pages/agent/debug-content';
import { buildBeginInputListFromObject } from '@/pages/agent/form/begin-form/utils';
import { useAwaitComponentData } from '@/pages/agent/hooks/use-chat-logic';
import { useSendNextSharedMessage } from '@/pages/agent/hooks/use-send-shared-message';
import { removeThinkSection } from '@/utils/chat';
import isEmpty from 'lodash/isEmpty';
import { MessageCircle, Minimize2, Send, X } from 'lucide-react';
import React, { useCallback, useEffect, useRef, useState } from 'react';
import { useTranslation } from 'react-i18next';
import {
useGetSharedChatSearchParams,
useSendSharedMessage,
} from '../pages/next-chats/hooks/use-send-shared-message';
import FloatingChatWidgetMarkdown from './floating-chat-widget-markdown';
/**
* Normalizes a hex color input and falls back to a safe default when invalid.
*/
const normalizeHexColor = (value: string | null, fallback: string) => {
return value && /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(value)
? value
: fallback;
};
/**
* Darkens a hex color to derive hover and gradient variants for the widget chrome.
*/
const darkenHexColor = (hexColor: string, amount = 0.12) => {
const normalizedHex = hexColor.replace('#', '');
const expandedHex =
normalizedHex.length === 3
? normalizedHex
.split('')
.map((char) => `${char}${char}`)
.join('')
: normalizedHex;
const channels = expandedHex.match(/.{2}/g);
if (!channels) {
return hexColor;
}
return `#${channels
.map((channel) => {
const value = parseInt(channel, 16);
const adjustedValue = Math.max(
0,
Math.min(255, Math.round(value * (1 - amount))),
);
return adjustedValue.toString(16).padStart(2, '0');
})
.join('')}`;
};
/**
* Accepts a footer link from the widget query string and returns a safe HTTP(S) URL.
*/
const normalizeWidgetFooterLink = (value: string | null) => {
const normalizedValue = value?.trim();
if (!normalizedValue) {
return undefined;
}
const candidate = /^[a-z][a-z\d+.-]*:/i.test(normalizedValue)
? normalizedValue
: `https://${normalizedValue}`;
try {
const url = new URL(candidate);
if (url.protocol === 'http:' || url.protocol === 'https:') {
return url.toString();
}
} catch {
return undefined;
}
return undefined;
};
/**
* Stable id for the seeded agent prologue. `addNewestOneAnswer` dedupes by
* message id, so a re-invoked effect (e.g. under React StrictMode) merges
* into the seeded message instead of appending a duplicate.
*/
const PROLOGUE_MESSAGE_ID = 'prologue';
/**
* How long a streaming answer may go without a content update before the
* typing indicator reappears (the canvas is working between components,
* e.g. the LLM thinking after a Message component emitted its template).
*/
const StreamStallTimeoutMs = 1000;
/**
* The chatbot flow has no form-submit path (only agent canvases pause on
* "Await response" nodes), so the await hook gets a noop there.
*/
const noopSendFormMessage = () => {};
interface AwaitInteractionProps {
message: IMessage;
isActive: boolean;
sendLoading: boolean;
buildInputList: ReturnType<typeof useAwaitComponentData>['buildInputList'];
handleOk: ReturnType<typeof useAwaitComponentData>['handleOk'];
}
/**
* Renders the agent's "Await response" (UserFillUp) interaction, mirroring
* web/src/pages/agent/share: the active (latest) await message shows the
* input form; resolved ones keep the tips as conversation history.
*/
const AwaitInteraction = ({
message,
isActive,
sendLoading,
buildInputList,
handleOk,
}: AwaitInteractionProps) => {
const { t } = useTranslation();
if (isActive) {
return (
<DebugContent
className="[&_input]:text-inherit [&_textarea]:text-inherit"
parameters={buildInputList(message)}
message={message}
ok={handleOk(message)}
isNext={false}
loading={sendLoading}
btnText={t('common.submit')}
/>
);
}
if (message?.data?.tips) {
return (
<p className="text-sm leading-relaxed whitespace-pre-wrap">
{message.data.tips}
</p>
);
}
return null;
};
/**
* Renders the embeddable floating chat widget and applies URL-driven widget settings.
*/
const FloatingChatWidget = () => {
const { t } = useTranslation();
const [isOpen, setIsOpen] = useState(false);
const [isMinimized, setIsMinimized] = useState(false);
const [inputValue, setInputValue] = useState('');
const [lastResponseId, setLastResponseId] = useState<string | null>(null);
const [displayMessages, setDisplayMessages] = useState<any[]>([]);
const [isLoaded, setIsLoaded] = useState(false);
const messagesEndRef = useRef<HTMLDivElement>(null);
const {
sharedId: conversationId,
locale,
from,
} = useGetSharedChatSearchParams();
const isFromAgent = from === SharedFrom.Agent;
// Check if we're in button-only mode or window-only mode
const urlParams = new URLSearchParams(window.location.search);
const mode = urlParams.get('mode') || 'full'; // 'button', 'window', or 'full'
const enableStreaming = urlParams.get('streaming') === 'true'; // Only enable if explicitly set to true
const isMuted = urlParams.get('muted') === 'true';
const widgetTitle = urlParams.get('widget_title')?.trim();
const widgetSubtitle = urlParams.get('widget_subtitle')?.trim();
const widgetFooter = urlParams.get('widget_footer')?.trim();
const widgetFooterLink = normalizeWidgetFooterLink(
urlParams.get('widget_footer_link'),
);
const widgetAccentColor = normalizeHexColor(
urlParams.get('widget_accent_color'),
'#2563eb',
);
const widgetAccentColorStrong = darkenHexColor(widgetAccentColor);
const widgetBackgroundColor = normalizeHexColor(
urlParams.get('widget_background_color'),
'#ffffff',
);
const widgetTextColor = normalizeHexColor(
urlParams.get('widget_text_color'),
'#111827',
);
const widgetHeaderTextColor = normalizeHexColor(
urlParams.get('widget_header_text_color'),
'#ffffff',
);
const widgetFooterTextColor = normalizeHexColor(
urlParams.get('widget_footer_text_color'),
'#111827',
);
const hookResult = (
isFromAgent ? useSendNextSharedMessage : useSendSharedMessage
)(() => {});
const {
handlePressEnter,
handleInputChange,
value: hookValue,
sendLoading,
derivedMessages,
hasError,
} = hookResult;
const findReferenceByMessageId = (hookResult as any).findReferenceByMessageId;
// Only the agent flow exposes these. The chat flow receives its prologue
// through the completions handshake instead, so both stay optional here.
const {
addNewestOneAnswer,
isTaskMode,
sendFormMessage,
inputsData,
ok: submitBeginParams,
} = hookResult as Partial<
Pick<
ReturnType<typeof useSendNextSharedMessage>,
| 'addNewestOneAnswer'
| 'isTaskMode'
| 'sendFormMessage'
| 'inputsData'
| 'ok'
>
>;
// An agent canvas pausing on an "Await response" node surfaces its form
// spec on the latest assistant message's `data.inputs`; isWaiting stays
// true until the user submits it (sendFormMessage resumes the run).
const { buildInputList, handleOk, isWaiting } = useAwaitComponentData({
derivedMessages: derivedMessages ?? [],
sendFormMessage: sendFormMessage ?? noopSendFormMessage,
});
const hasAwaitInputs = useCallback(
(message: IMessage) => buildInputList(message).length > 0,
[buildInputList],
);
// An agent's Begin component inputs reach the completions endpoint only
// after `ok` stores them in the send hook, so collect them up front the
// same way pages/agent/share does: a forced parameter dialog shown while
// the inputs are known but not yet submitted. Only the modes rendering
// the chat UI show it — in button/master mode the sibling window-mode
// iframe runs its own copy.
const beginInputs = inputsData?.inputs;
const hasBeginInputs = isFromAgent && !isEmpty(beginInputs);
const canShowBeginDialog = mode === 'window' || (mode === 'full' && isOpen);
const [beginParamsSubmitted, setBeginParamsSubmitted] = useState(false);
const handleSubmitBeginParams = useCallback(
(params: any[]) => {
submitBeginParams?.(params);
setBeginParamsSubmitted(true);
},
[submitBeginParams],
);
// Sync our local input with the hook's value when needed
useEffect(() => {
if (hookValue && hookValue !== inputValue) {
setInputValue(hookValue);
}
}, [hookValue, inputValue]);
const { data, loading: infoLoading } = (
isFromAgent ? useFetchExternalAgentInputs : useFetchExternalChatInfo
)();
// Seed the agent's opening statement. The agent send hook derives the
// prologue from the agent canvas graph store, which is never populated on
// the widget page, so mirror pages/agent/share and take the prologue from
// the agentbots inputs endpoint instead. The chat flow already gets its
// prologue from the completions handshake.
useEffect(() => {
if (!isFromAgent || isTaskMode) {
return;
}
if (data?.prologue) {
addNewestOneAnswer?.({
answer: data.prologue,
id: PROLOGUE_MESSAGE_ID,
});
}
}, [isFromAgent, isTaskMode, data?.prologue, addNewestOneAnswer]);
const title = data.title;
const displayTitle = widgetTitle || title || t('chat.chatSupport');
const displaySubtitle = widgetSubtitle || t('chat.replyInstantly');
const displayFooter = widgetFooter || '';
const renderFooter = () => {
if (!displayFooter) {
return null;
}
return (
<div
className="mt-3 -mx-4 -mb-4 px-4 py-3 text-center text-xs"
style={{
backgroundColor: widgetAccentColor,
color: widgetFooterTextColor,
}}
>
{widgetFooterLink ? (
<a
href={widgetFooterLink}
target="_blank"
rel="noreferrer"
className="underline underline-offset-2 hover:opacity-90"
style={{ color: widgetFooterTextColor }}
>
{displayFooter}
</a>
) : (
displayFooter
)}
</div>
);
};
const widgetFormControlStyle = {
color: widgetTextColor,
'--bg-input': `color-mix(in srgb, ${widgetTextColor} 5%, transparent)`,
'--border-button': `color-mix(in srgb, ${widgetTextColor} 20%, transparent)`,
} as React.CSSProperties;
const bodyContainerStyle: React.CSSProperties = {
...widgetFormControlStyle,
borderRadius: '0 0 16px 16px',
backgroundColor: widgetBackgroundColor,
};
const inputStyle: React.CSSProperties = {
minHeight: '44px',
maxHeight: '120px',
color: widgetTextColor,
backgroundColor: widgetBackgroundColor,
};
const { visible, hideModal, documentId, selectedChunk, clickDocumentButton } =
useClickDrawer();
// PDF drawer state tracking
useEffect(() => {
// Drawer state management
}, [visible, documentId, selectedChunk]);
// Play sound when opening
const playNotificationSound = useCallback(() => {
if (isMuted) {
return;
}
try {
const audioContext = new (
window.AudioContext || (window as any).webkitAudioContext
)();
const oscillator = audioContext.createOscillator();
const gainNode = audioContext.createGain();
oscillator.connect(gainNode);
gainNode.connect(audioContext.destination);
oscillator.frequency.value = 800;
oscillator.type = 'sine';
gainNode.gain.setValueAtTime(0.3, audioContext.currentTime);
gainNode.gain.exponentialRampToValueAtTime(
0.01,
audioContext.currentTime + 0.3,
);
oscillator.start(audioContext.currentTime);
oscillator.stop(audioContext.currentTime + 0.3);
} catch (error) {
console.warn(error);
// Silent fail if audio not supported
}
}, [isMuted]);
// Play sound for AI responses (Intercom-style)
const playResponseSound = useCallback(() => {
if (isMuted) {
return;
}
try {
const audioContext = new (
window.AudioContext || (window as any).webkitAudioContext
)();
const oscillator = audioContext.createOscillator();
const gainNode = audioContext.createGain();
oscillator.connect(gainNode);
gainNode.connect(audioContext.destination);
oscillator.frequency.value = 600;
oscillator.type = 'sine';
gainNode.gain.setValueAtTime(0.2, audioContext.currentTime);
gainNode.gain.exponentialRampToValueAtTime(
0.01,
audioContext.currentTime + 0.2,
);
oscillator.start(audioContext.currentTime);
oscillator.stop(audioContext.currentTime + 0.2);
} catch (error) {
console.warn(error);
// Silent fail if audio not supported
}
}, [isMuted]);
// Set loaded state and locale
useEffect(() => {
// Set component as loaded after a brief moment to prevent flash
const timer = setTimeout(() => {
setIsLoaded(true);
// Tell parent window that we're ready to be shown
window.parent.postMessage(
{
type: 'WIDGET_READY',
},
'*',
);
}, 50);
if (locale && i18n.language !== locale) {
changeLanguageAsync(locale, { persist: false });
}
return () => clearTimeout(timer);
}, [locale]);
// Handle message display based on streaming preference
useEffect(() => {
if (!derivedMessages) {
setDisplayMessages([]);
return;
}
if (enableStreaming) {
// Show messages as they stream
setDisplayMessages(derivedMessages);
} else {
// Only show complete messages (non-streaming mode)
const completeMessages = derivedMessages.filter((msg, index) => {
// Always show user messages immediately
if (msg.role === MessageType.User) return true;
// For AI messages, only show when response is complete (not loading)
if (msg.role === MessageType.Assistant) {
return !sendLoading || index < derivedMessages.length - 1;
}
return true;
});
setDisplayMessages(completeMessages);
}
}, [derivedMessages, enableStreaming, sendLoading]);
// Auto-scroll to bottom when display messages change
useEffect(() => {
messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
}, [displayMessages]);
// Render different content based on mode
// Master mode - handles everything and creates second iframe dynamically
useEffect(() => {
if (mode !== 'master') return;
const isInIframe = window.self !== window.top;
if (isInIframe) {
// Embedded: tell parent to create chat window iframe
window.parent.postMessage(
{
type: 'CREATE_CHAT_WINDOW',
src: window.location.href.replace('mode=master', 'mode=window'),
},
'*',
);
} else {
// Standalone: create chat window iframe ourselves
if (!document.getElementById('chat-win')) {
const i = document.createElement('iframe');
i.id = 'chat-win';
i.src = window.location.href.replace('mode=master', 'mode=window');
i.style.cssText =
'position:fixed;bottom:104px;right:24px;width:380px;height:500px;border:none;background:transparent;z-index:9998;display:none';
i.frameBorder = '0';
i.allow = 'microphone;camera';
document.body.appendChild(i);
}
}
// Listen for toggle messages to show/hide the chat window iframe
const handleToggle = (e: MessageEvent) => {
if (e.data.type === 'TOGGLE_CHAT') {
const chatWindow = document.getElementById(
'chat-win',
) as HTMLIFrameElement;
if (chatWindow) {
chatWindow.style.display = e.data.isOpen ? 'block' : 'none';
}
}
};
window.addEventListener('message', handleToggle);
return () => window.removeEventListener('message', handleToggle);
}, [mode]);
// Play sound only when AI response is complete (not streaming chunks)
useEffect(() => {
if (derivedMessages && derivedMessages.length > 0 && !sendLoading) {
const lastMessage = derivedMessages[derivedMessages.length - 1];
if (
lastMessage.role === MessageType.Assistant &&
lastMessage.id !== lastResponseId &&
derivedMessages.length > 1
) {
setLastResponseId(lastMessage.id || '');
playResponseSound();
}
}
}, [derivedMessages, sendLoading, lastResponseId, playResponseSound]);
const toggleChat = useCallback(() => {
if (mode === 'button') {
// In button mode, communicate with parent window to show/hide chat window
window.parent.postMessage(
{
type: 'TOGGLE_CHAT',
isOpen: !isOpen,
},
'*',
);
setIsOpen(!isOpen);
if (!isOpen) {
playNotificationSound();
}
} else {
// In full mode, handle locally
if (!isOpen) {
setIsOpen(true);
setIsMinimized(false);
playNotificationSound();
} else {
setIsOpen(false);
setIsMinimized(false);
}
}
}, [isOpen, mode, playNotificationSound]);
const minimizeChat = useCallback(() => {
setIsMinimized(true);
}, []);
// Initial loading covers the first external-info fetch and the chatbot
// session handshake: no messages exist yet, so a centered spinner (same
// pattern as the chat list page) replaces the empty message area and the
// input stays disabled — this also closes the race where a fast message
// goes out before the Begin-parameter dialog appears.
const isInitialLoading =
(infoLoading || sendLoading) && (displayMessages?.length ?? 0) === 0;
// Waiting-for-reply indicator, mirroring the "..." bubble of the agent
// debug chat: up from the moment the question goes out until the first
// assistant content arrives. In non-streaming mode the in-progress bubble
// is filtered out of displayMessages, so it stays up for the whole round
// trip; in streaming mode it covers the pre-first-frame gap and, via the
// stall detection below, mid-stream pauses between canvas components.
const lastDisplayMessage = displayMessages?.at(-1);
const latestStreamContent = lastDisplayMessage?.content;
// A streaming answer whose content stops growing past the timeout means
// the canvas is working without emitting (e.g. the LLM thinking after a
// Message component echoed the begin variables). The timer resets on
// every token, so steady streaming never triggers it; comparing the
// captured content instead of resetting state keeps the effect free of
// synchronous setState.
const [stalledStreamContent, setStalledStreamContent] = useState<
string | undefined
>();
useEffect(() => {
if (!sendLoading) {
return;
}
const stalledContent = latestStreamContent;
const timer = setTimeout(
() => setStalledStreamContent(stalledContent),
StreamStallTimeoutMs,
);
return () => clearTimeout(timer);
}, [sendLoading, latestStreamContent]);
const isStreamStalled =
sendLoading &&
stalledStreamContent !== undefined &&
stalledStreamContent === latestStreamContent;
const isAwaitingReply =
sendLoading &&
!isInitialLoading &&
(!enableStreaming ||
lastDisplayMessage?.role === MessageType.User ||
isStreamStalled);
const handleSendMessage = useCallback(() => {
if (!inputValue.trim() || sendLoading || isWaiting || isInitialLoading)
return;
// Update the hook's internal state first
const syntheticEvent = {
target: { value: inputValue },
currentTarget: { value: inputValue },
preventDefault: () => {},
} as any;
handleInputChange(syntheticEvent);
// Wait for state to update, then send
setTimeout(() => {
handlePressEnter({ enableThinking: '0', enableInternet: false });
// Clear our local input after sending
setInputValue('');
}, 50);
}, [
inputValue,
sendLoading,
isWaiting,
isInitialLoading,
handleInputChange,
handlePressEnter,
]);
const handleKeyPress = useCallback(
(e: React.KeyboardEvent) => {
if (e.key === 'Enter' && !e.shiftKey && !e.nativeEvent.isComposing) {
e.preventDefault();
handleSendMessage();
}
},
[handleSendMessage],
);
// Assistant bubble body shared by the window and full modes. Messages
// carrying an await-form spec render the AwaitInteraction instead of the
// markdown body — their content is empty by design (the canvas paused
// before producing an answer), which the markdown view would otherwise
// misrender as a permanent "Searching..." placeholder.
const renderAssistantMessageContent = useCallback(
(message: IMessage, index: number) => {
if (hasAwaitInputs(message)) {
return (
<AwaitInteraction
message={message}
isActive={index === displayMessages.length - 1}
sendLoading={sendLoading}
buildInputList={buildInputList}
handleOk={handleOk}
/>
);
}
return (
<>
<FloatingChatWidgetMarkdown
loading={
enableStreaming &&
sendLoading &&
index === displayMessages.length - 1
}
content={message.content}
reference={
findReferenceByMessageId?.(message.id) ||
message.reference || {
doc_aggs: [],
chunks: [],
total: 0,
}
}
clickDocumentButton={clickDocumentButton}
/>
<div className="flex justify-end" role="toolbar">
<CopyToClipboard
text={removeThinkSection(message.content)}
className="border-0"
size="icon-xs"
/>
</div>
</>
);
},
[
buildInputList,
clickDocumentButton,
displayMessages.length,
enableStreaming,
findReferenceByMessageId,
handleOk,
hasAwaitInputs,
sendLoading,
],
);
// Begin-parameter dialog shared by the window and full modes. Non-closable
// like the share page: chatting without these inputs would send empty
// Begin variables for the whole conversation. The width follows the small
// widget iframe instead of the modal's 700px default.
const beginParamsDialog = hasBeginInputs &&
canShowBeginDialog &&
!beginParamsSubmitted &&
submitBeginParams && (
<Modal
open
title={t('flow.beginInput')}
closable={false}
showfooter={false}
maskClosable={false}
size="small"
className="w-[calc(100vw-2rem)]"
>
<div className="mb-4" style={widgetFormControlStyle}>
<DebugContent
className="[&_input]:text-inherit [&_textarea]:text-inherit"
parameters={buildBeginInputListFromObject(beginInputs ?? {})}
ok={handleSubmitBeginParams}
isNext={false}
btnText={t('common.submit')}
/>
</div>
</Modal>
);
if (!conversationId) {
return (
<div className="fixed bottom-5 right-5 z-50">
<div className="bg-red-500 text-white p-4 rounded-lg shadow-lg">
Error: No conversation ID provided
</div>
</div>
);
}
// Remove the blocking return - we'll handle visibility with CSS instead
const messageCount = displayMessages?.length || 0;
// Show just the button in master mode
if (mode === 'master') {
return (
<div
className={`fixed bottom-6 right-6 z-50 transition-opacity duration-300 ${isLoaded ? 'opacity-100' : 'opacity-0'}`}
>
<button
type="button"
onClick={() => {
const newIsOpen = !isOpen;
setIsOpen(newIsOpen);
if (newIsOpen) playNotificationSound();
// Send toggle message to parent (if embedded) or self (if standalone)
const target = window.self !== window.top ? window.parent : window;
target.postMessage(
{
type: 'TOGGLE_CHAT',
isOpen: newIsOpen,
},
'*',
);
}}
className={`w-14 h-14 text-white rounded-full transition-all duration-300 flex items-center justify-center group ${
isOpen ? 'scale-95' : 'scale-100 hover:scale-105'
}`}
style={{ backgroundColor: widgetAccentColor }}
>
<div
className={`transition-transform duration-300 ${isOpen ? 'rotate-45' : 'rotate-0'}`}
>
{isOpen ? <X size={24} /> : <MessageCircle size={24} />}
</div>
</button>
{/* Unread Badge */}
{!isOpen && messageCount > 0 && (
<div className="absolute -top-2 -right-2 w-6 h-6 bg-red-500 text-white text-xs font-bold rounded-full flex items-center justify-center animate-pulse">
{messageCount > 9 ? '9+' : messageCount}
</div>
)}
</div>
);
}
if (mode === 'button') {
// Only render the floating button
return (
<div
className={`fixed bottom-6 right-6 z-50 transition-opacity duration-300 ${isLoaded ? 'opacity-100' : 'opacity-0'}`}
>
<button
type="button"
onClick={toggleChat}
className={`w-14 h-14 text-white rounded-full transition-all duration-300 flex items-center justify-center group ${
isOpen ? 'scale-95' : 'scale-100 hover:scale-105'
}`}
style={{ backgroundColor: widgetAccentColor }}
>
<div
className={`transition-transform duration-300 ${isOpen ? 'rotate-45' : 'rotate-0'}`}
>
{isOpen ? <X size={24} /> : <MessageCircle size={24} />}
</div>
</button>
{/* Unread Badge */}
{!isOpen && messageCount > 0 && (
<div className="absolute -top-2 -right-2 w-6 h-6 bg-red-500 text-white text-xs font-bold rounded-full flex items-center justify-center animate-pulse">
{messageCount > 9 ? '9+' : messageCount}
</div>
)}
</div>
);
}
if (mode === 'window') {
// Only render the chat window (always open)
return (
<>
<div
className={`fixed top-0 left-0 z-50 rounded-2xl transition-all duration-300 ease-out h-[500px] w-[380px] overflow-hidden ${isLoaded ? 'opacity-100' : 'opacity-0'}`}
style={{ backgroundColor: widgetAccentColor }}
>
{/* Header */}
<div
className="flex items-center justify-between p-4 text-white rounded-t-2xl"
style={{
background: `linear-gradient(to right, ${widgetAccentColor}, ${widgetAccentColorStrong})`,
}}
>
<div className="flex items-center space-x-3 min-w-0">
<div className="w-8 h-8 bg-white bg-opacity-20 rounded-full flex items-center justify-center shrink-0">
<MessageCircle size={18} />
</div>
<div className="min-w-0">
<h3
className="font-semibold text-sm truncate"
style={{ color: widgetHeaderTextColor }}
title={displayTitle}
>
{displayTitle}
</h3>
<p
className="text-xs truncate"
style={{ color: widgetHeaderTextColor }}
title={displaySubtitle}
>
{displaySubtitle}
</p>
</div>
</div>
</div>
{/* Messages and Input */}
<div className="flex flex-col h-[436px]" style={bodyContainerStyle}>
<div
className="flex-1 overflow-y-auto p-4 space-y-4"
onWheel={(e) => {
const element = e.currentTarget;
const isAtTop = element.scrollTop === 0;
const isAtBottom =
element.scrollTop + element.clientHeight >=
element.scrollHeight - 1;
// Allow scroll to pass through to parent when at boundaries
if ((isAtTop && e.deltaY < 0) || (isAtBottom && e.deltaY > 0)) {
e.preventDefault();
// Let the parent handle the scroll
window.parent.postMessage(
{
type: 'SCROLL_PASSTHROUGH',
deltaY: e.deltaY,
},
'*',
);
}
}}
>
{isInitialLoading && (
<div className="flex h-full items-center justify-center">
<Spin size="large" />
</div>
)}
{displayMessages?.map((message, index) => (
<div
key={index}
className={`flex ${message.role === MessageType.User ? 'justify-end' : 'justify-start'}`}
>
<div
className={`${
message.role === MessageType.Assistant &&
hasAwaitInputs(message)
? 'w-full'
: 'max-w-[280px]'
} min-w-0 break-words px-4 py-2 rounded-2xl ${
message.role === MessageType.User
? 'text-white rounded-br-md'
: 'rounded-bl-md'
}`}
style={
message.role === MessageType.User
? { backgroundColor: widgetAccentColor }
: {
backgroundColor: 'rgba(148, 163, 184, 0.14)',
color: widgetTextColor,
}
}
>
{message.role === MessageType.User ? (
<p className="text-sm leading-relaxed whitespace-pre-wrap text-wrap">
{message.content}
</p>
) : (
<div className="space-y-2">
{renderAssistantMessageContent(message, index)}
</div>
)}
</div>
</div>
))}
{/* Clean Typing Indicator */}
{isAwaitingReply && (
<div className="flex justify-start pl-4">
<div className="flex space-x-1">
<div
className="w-2 h-2 rounded-full animate-bounce"
style={{ backgroundColor: widgetAccentColor }}
></div>
<div
className="w-2 h-2 rounded-full animate-bounce"
style={{
backgroundColor: widgetAccentColor,
animationDelay: '0.1s',
}}
></div>
<div
className="w-2 h-2 rounded-full animate-bounce"
style={{
backgroundColor: widgetAccentColor,
animationDelay: '0.2s',
}}
></div>
</div>
</div>
)}
<div ref={messagesEndRef} />
</div>
{/* Input Area */}
<div
className="border-t border-gray-200 p-4"
style={bodyContainerStyle}
>
<div className="flex items-end space-x-3">
<div className="flex-1">
<textarea
value={inputValue}
onChange={(e) => {
const newValue = e.target.value;
setInputValue(newValue);
handleInputChange(e);
}}
onKeyPress={handleKeyPress}
placeholder={t('chat.typeYourMessage')}
rows={1}
className="w-full resize-none border border-gray-300 rounded-2xl px-4 py-3 text-sm focus:outline-none focus:ring-2 focus:border-transparent"
style={inputStyle}
disabled={
hasError || sendLoading || isWaiting || isInitialLoading
}
/>
</div>
<button
type="button"
onClick={handleSendMessage}
disabled={
!inputValue.trim() ||
sendLoading ||
isWaiting ||
isInitialLoading
}
className="p-3 text-white rounded-full disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
style={{ backgroundColor: widgetAccentColor }}
>
<Send size={18} />
</button>
</div>
{renderFooter()}
</div>
</div>
</div>
{beginParamsDialog}
{visible && (
<PdfSheet
visible={visible}
hideModal={hideModal}
documentId={documentId}
chunk={selectedChunk}
width={'100vw'}
height={'100vh'}
/>
)}
</>
);
} // Full mode - render everything together (original behavior)
return (
<div
className={`transition-opacity duration-300 ${isLoaded ? 'opacity-100' : 'opacity-0'}`}
>
{/* Chat Widget Container */}
{isOpen && (
<div
className={`fixed bottom-24 right-6 z-50 rounded-2xl transition-all duration-300 ease-out ${
isMinimized ? 'h-16' : 'h-[500px]'
} w-[380px] overflow-hidden`}
style={{ backgroundColor: widgetAccentColor }}
>
{/* Header */}
<div
className="flex items-center justify-between p-4 text-white rounded-t-2xl"
style={{
background: `linear-gradient(to right, ${widgetAccentColor}, ${widgetAccentColorStrong})`,
}}
>
<div className="flex items-center space-x-3 min-w-0">
<div className="w-8 h-8 bg-white bg-opacity-20 rounded-full flex items-center justify-center shrink-0">
<MessageCircle size={18} />
</div>
<div className="min-w-0">
<h3
className="font-semibold text-sm truncate"
style={{ color: widgetHeaderTextColor }}
title={displayTitle}
>
{displayTitle}
</h3>
<p
className="text-xs truncate"
style={{ color: widgetHeaderTextColor }}
title={displaySubtitle}
>
{displaySubtitle}
</p>
</div>
</div>
<div className="flex items-center space-x-1 shrink-0">
<button
type="button"
onClick={minimizeChat}
className="p-1.5 hover:bg-white hover:bg-opacity-20 rounded-full transition-colors"
>
<Minimize2 size={16} />
</button>
<button
type="button"
onClick={toggleChat}
className="p-1.5 hover:bg-white hover:bg-opacity-20 rounded-full transition-colors"
>
<X size={16} />
</button>
</div>
</div>
{/* Messages Container */}
{!isMinimized && (
<div className="flex flex-col h-[436px]" style={bodyContainerStyle}>
<div
className="flex-1 overflow-y-auto p-4 space-y-4"
onWheel={(e) => {
const element = e.currentTarget;
const isAtTop = element.scrollTop === 0;
const isAtBottom =
element.scrollTop + element.clientHeight >=
element.scrollHeight - 1;
// Allow scroll to pass through to parent when at boundaries
if (
(isAtTop && e.deltaY < 0) ||
(isAtBottom && e.deltaY > 0)
) {
e.preventDefault();
// Let the parent handle the scroll
window.parent.postMessage(
{
type: 'SCROLL_PASSTHROUGH',
deltaY: e.deltaY,
},
'*',
);
}
}}
>
{isInitialLoading && (
<div className="flex h-full items-center justify-center">
<Spin size="large" />
</div>
)}
{displayMessages?.map((message, index) => (
<div
key={index}
className={`flex ${message.role === MessageType.User ? 'justify-end' : 'justify-start'}`}
>
<div
className={`${
message.role === MessageType.Assistant &&
hasAwaitInputs(message)
? 'w-full'
: 'max-w-[280px]'
} min-w-0 break-words px-4 py-2 rounded-2xl ${
message.role === MessageType.User
? 'text-white rounded-br-md'
: 'rounded-bl-md'
}`}
style={
message.role === MessageType.User
? { backgroundColor: widgetAccentColor }
: {
backgroundColor: 'rgba(148, 163, 184, 0.14)',
color: widgetTextColor,
}
}
>
{message.role === MessageType.User ? (
<p className="text-sm leading-relaxed whitespace-pre-wrap">
{message.content}
</p>
) : (
<div className="space-y-2">
{renderAssistantMessageContent(message, index)}
</div>
)}
</div>
</div>
))}
{/* Typing Indicator */}
{isAwaitingReply && (
<div className="flex justify-start">
<div className="bg-gray-100 rounded-2xl rounded-bl-md px-4 py-3">
<div className="flex space-x-1">
<div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce"></div>
<div
className="w-2 h-2 bg-gray-400 rounded-full animate-bounce"
style={{ animationDelay: '0.1s' }}
></div>
<div
className="w-2 h-2 bg-gray-400 rounded-full animate-bounce"
style={{ animationDelay: '0.2s' }}
></div>
</div>
</div>
</div>
)}
<div ref={messagesEndRef} />
</div>
{/* Input Area */}
<div className="border-t border-gray-200 p-4">
<div className="flex items-end space-x-3">
<div className="flex-1">
<textarea
value={inputValue}
onChange={(e) => {
const newValue = e.target.value;
setInputValue(newValue);
// Also update the hook's state
handleInputChange(e);
}}
onKeyPress={handleKeyPress}
placeholder={t('chat.typeYourMessage')}
rows={1}
className="w-full resize-none border border-gray-300 rounded-2xl px-4 py-3 text-sm focus:outline-none focus:ring-2 focus:border-transparent"
style={inputStyle}
disabled={
hasError || sendLoading || isWaiting || isInitialLoading
}
/>
</div>
<button
type="button"
onClick={handleSendMessage}
disabled={
!inputValue.trim() ||
sendLoading ||
isWaiting ||
isInitialLoading
}
className="p-3 text-white rounded-full disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
style={{ backgroundColor: widgetAccentColor }}
>
<Send size={18} />
</button>
</div>
{renderFooter()}
</div>
</div>
)}
</div>
)}
{/* Floating Button */}
<div className="fixed bottom-6 right-6 z-50">
<button
type="button"
onClick={toggleChat}
className={`w-14 h-14 text-white rounded-full transition-all duration-300 flex items-center justify-center group ${
isOpen ? 'scale-95' : 'scale-100 hover:scale-105'
}`}
style={{ backgroundColor: widgetAccentColor }}
>
<div
className={`transition-transform duration-300 ${isOpen ? 'rotate-45' : 'rotate-0'}`}
>
{isOpen ? <X size={24} /> : <MessageCircle size={24} />}
</div>
</button>
{/* Unread Badge */}
{!isOpen && messageCount > 0 && (
<div className="absolute -top-2 -right-2 w-6 h-6 bg-red-500 text-white text-xs font-bold rounded-full flex items-center justify-center animate-pulse">
{messageCount > 9 ? '9+' : messageCount}
</div>
)}
</div>
{beginParamsDialog}
<PdfSheet
visible={visible}
hideModal={hideModal}
documentId={documentId}
chunk={selectedChunk}
/>
</div>
);
};
export default FloatingChatWidget;