@projectcor/maia-components 2.28.0 → 2.30.0

package/lib/components/molecules/ChatAIMessages/ChatAIMessages.js

@@ -0,0 +1,853 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["isCurrentUser", "children"],
+  _excluded2 = ["isCurrentUser"];
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/* eslint-disable import/no-extraneous-dependencies */
+/* eslint-disable @typescript-eslint/indent */
+/* eslint-disable react/no-unstable-nested-components */
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable no-nested-ternary */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-undef */
+/* eslint-disable react/function-component-definition */
+/* eslint-disable react/require-default-props */
+/* eslint-disable jsx-a11y/click-events-have-key-events */
+/* eslint-disable jsx-a11y/no-static-element-interactions */
+import React, { memo, useCallback, useEffect, useLayoutEffect, useRef, useState, createElement as _createElement } from 'react';
+import { ArrowSmallDown } from '@projectcor/icons/lib/components/ArrowSmallDown';
+import { AttachmentCard } from '../../atoms/AttachmentCard/AttachmentCard';
+import { ApprovalBox } from '../../atoms/ApprovalBox/ApprovalBox';
+import { AttachmentPreviewModal } from '../../atoms/AttachmentPreviewModal';
+import { AttachmentCardAudio } from '../../atoms/AttachmentCard/AttachmentCardAudio';
+import { MaiaStreamdown } from '../../atoms/MaiaStreamdown';
+import { ChatHistoryRole } from '../../../types/Chat';
+import { renderTextWithMentions, hasInlineMarkers } from '../../../utils/renderContextMentions';
+import { isMaiakerAgent } from '../../../utils/agentDisplayName';
+import { useUser } from '../../../context/cor-user';
+import { useT } from '../../../hooks/useT';
+import { useChatManager } from '../../../hooks/useChatManager/useChatManager';
+import { useSmoothStreamText } from '../../../hooks/useSmoothStreamText';
+import { useStreamingMessage } from '../../../hooks/useStreamingMessage';
+import { LoadingText } from '../../atoms/LoadingText';
+import { AgentActivityIndicator } from '../../atoms/AgentActivityIndicator';
+import { isStreamingPlaceholderMessageId, resolveStreamLoadingDisplay } from '../../../utils/streamActivityMessages';
+import { resolveRetryTurnId, findUserMessageForRetry } from '../../../utils/retryCompletion';
+import { Loader } from '../../atoms/Loader';
+import { Fade } from '../../atoms/Fade';
+import { MessageFromUser, MessageFromOther, MessageContentFromUser, MessageContentFromOther } from './styles';
+import { MessageFeedback } from '../MessageFeedback';
+import { SCCAIMessageWrapper, ScrollToBottomButton, SCMessagesOuter, SCMessagesScroll, SCMessagesInner, SCLoadingMessagesColumn, SCOptionsList, SCOptionItem, SCMessageItemWrapper, SCMessageItemInner, SCAttachmentsRow, SCApprovalActionsColumn } from './newStyles';
+import { Feedback } from '../MessageFeedback/MessageFeedback';
+import { useGlobalContext } from '../../../context/global-context';
+import { EntityLinkCustomLink, getEntityLinkWrapperClassName } from '../../../utils/entityLinkRender';
+import { ChatAISuggestions } from './ChatAISuggestions';
+import { ChatAICreateAgentActions } from './ChatAICreateAgentActions';
+import { EVENTS, useEvent } from '../../../hooks/useEvent';
+import { downloadFileFromUrl } from '../../../utils/fileDownloadHelper';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+var MessageWrapper = function MessageWrapper(_ref) {
+  var isCurrentUser = _ref.isCurrentUser,
+    children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var MessageComponent = isCurrentUser ? MessageFromUser : MessageFromOther;
+  return /*#__PURE__*/_jsx(MessageComponent, _objectSpread(_objectSpread({}, props), {}, {
+    children: children
+  }));
+};
+var MessageContentWrapper = function MessageContentWrapper(_ref2) {
+  var isCurrentUser = _ref2.isCurrentUser,
+    props = _objectWithoutProperties(_ref2, _excluded2);
+  var MessageContentComponent = isCurrentUser ? MessageContentFromUser : MessageContentFromOther;
+  return /*#__PURE__*/_jsx(MessageContentComponent, _objectSpread({}, props));
+};
+function MessageOptions(_ref3) {
+  var options = _ref3.options,
+    handleSelectOption = _ref3.handleSelectOption;
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    selectedOption = _useState2[0],
+    setSelectedOption = _useState2[1];
+  var handleSelect = function handleSelect(option) {
+    if (selectedOption) return;
+    setSelectedOption(option);
+    handleSelectOption(option);
+  };
+  return /*#__PURE__*/_jsx(SCOptionsList, {
+    children: (options || []).map(function (option) {
+      return /*#__PURE__*/_jsx(SCOptionItem, {
+        $hasSelection: !!selectedOption,
+        $dimmed: !!selectedOption && (selectedOption === null || selectedOption === void 0 ? void 0 : selectedOption.id) !== option.id,
+        onClick: function onClick() {
+          return handleSelect(option);
+        },
+        children: option.name
+      }, option.id);
+    })
+  });
+}
+
+/** Solo este componente re-renderiza cuando cambia el texto en streaming (lee del context). */
+var StreamingMessageBody = /*#__PURE__*/memo(function (props) {
+  var _props$createAgentFol, _props$suggestions;
+  // Texto del stream: solo se lee del store cuando este mensaje es el
+  // que está en streaming. useSyncExternalStore aísla el re-render a
+  // este componente, sin tocar el resto del árbol.
+  var streamingText = useStreamingMessage(props.isStreaming ? props.messageId : null);
+  var rawText = props.isStreaming ? streamingText : props.message;
+  // Smooth streaming: desacopla la cadencia del backend del render.
+  // Durante el streaming libera chars a ritmo constante vía rAF; cuando
+  // termina, muestra el texto final al instante (sin animación residual).
+  // Los defaults del hook se ajustaron empíricamente en staging; aun así
+  // se exponen flags de runtime (window.*) para poder tunear sin recompilar
+  // si algún backend presenta una cadencia muy distinta en producción.
+  //   window.streamAdapt = false      // desactiva adaptación al backend
+  //   window.streamBufferMs = 600     // colchón objetivo (ms)
+  //   window.streamLagMs = 450        // lag máximo base (ms)
+  //   window.streamMinBuffer = 70     // piso del colchón en chars
+  //   window.streamWarmupMs = 400     // warmup inicial (ms)
+  var winFlags = typeof window !== 'undefined' ? window : {};
+  var displayText = useSmoothStreamText(rawText, _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({
+    enabled: !!props.isStreaming,
+    maxCharsPerFrame: 24,
+    snapToWordBoundary: true
+  }, winFlags.streamLagMs != null && {
+    targetLagMs: winFlags.streamLagMs
+  }), winFlags.streamAdapt != null && {
+    adaptToBackendRate: winFlags.streamAdapt
+  }), winFlags.streamBufferMs != null && {
+    targetBufferMs: winFlags.streamBufferMs
+  }), winFlags.streamMinBuffer != null && {
+    minBufferChars: winFlags.streamMinBuffer
+  }), winFlags.streamWarmupMs != null && {
+    warmupMs: winFlags.streamWarmupMs
+  }));
+  var createAgentActionsAgentId = (_props$createAgentFol = props.createAgentFollowUp) === null || _props$createAgentFol === void 0 ? void 0 : _props$createAgentFol.agentId;
+  if (!displayText && !props.isStreaming) return null;
+  var hasMentions = hasInlineMarkers(displayText);
+  var mentionNodes = hasMentions ? renderTextWithMentions(displayText) : null;
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx(SCCAIMessageWrapper, {
+      isCurrentUser: props.isCurrentUser,
+      isFrontendCancelled: props.isFrontendCancelled,
+      className: getEntityLinkWrapperClassName(displayText),
+      children: hasMentions && mentionNodes ?
+      /*#__PURE__*/
+      // Si hay mentions, renderizar directamente (sin markdown en el mismo párrafo)
+      _jsx("span", {
+        style: {
+          display: 'inline'
+        },
+        children: mentionNodes
+      }) :
+      /*#__PURE__*/
+      // Sin mentions, pasar a Streamdown para markdown support
+      _jsx(MaiaStreamdown, {
+        variant: "chat",
+        isCurrentUser: props.isCurrentUser,
+        isFrontendCancelled: props.isFrontendCancelled,
+        components: {
+          a: EntityLinkCustomLink
+        },
+        isAnimating: !!props.isStreaming,
+        children: displayText
+      })
+    }), props.isAssistant && !props.isError && !props.approval && !props.isStreaming && (!props.isFrontendCancelled || !!props.onRetry) && /*#__PURE__*/_jsx(MessageFeedback, {
+      content: displayText,
+      sources: props.isFrontendCancelled ? undefined : props.sources,
+      handleFeedback: props.isFrontendCancelled ? undefined : props.handleFeedbackClick,
+      disableFeedback: props.disableFeedback,
+      onRetry: props.onRetry
+    }), props.isAssistant && !props.isFrontendCancelled && !props.approval && (!props.isError || ((_props$suggestions = props.suggestions) === null || _props$suggestions === void 0 ? void 0 : _props$suggestions.length)) && /*#__PURE__*/_jsx(ChatAISuggestions, {
+      suggestions: props.suggestions || [],
+      onSelectSuggestion: function onSelectSuggestion(suggestion) {
+        return props.handleSuggestionClick(props.messageId, suggestion);
+      },
+      disabled: props.suggestionsDisabled,
+      hidden: !!props.isStreaming || !props.isLastMessage || !!props.suggestionsDisabled
+    }), props.isAssistant && !props.isError && !props.isFrontendCancelled && !props.approval && !!createAgentActionsAgentId && /*#__PURE__*/_jsx(ChatAICreateAgentActions, {
+      agentId: createAgentActionsAgentId,
+      disabled: props.suggestionsDisabled,
+      hidden: !!props.isStreaming || !props.isLastMessage || !!props.suggestionsDisabled
+    })]
+  });
+});
+var MessageItem = /*#__PURE__*/memo(function (props) {
+  var _props$projectMetadat;
+  var id = props.id,
+    user = props.user,
+    message = props.message,
+    isStreaming = props.isStreaming,
+    isError = props.isError,
+    authUser = props.authUser,
+    options = props.options,
+    isChangeProject = props.isChangeProject,
+    handleSelectOption = props.handleSelectOption,
+    handleSuggestionClick = props.handleSuggestionClick,
+    handleFeedback = props.handleFeedback,
+    handleApprovalDecision = props.handleApprovalDecision,
+    disableFeedback = props.disableFeedback,
+    handleRetry = props.handleRetry,
+    role = props.role,
+    sources = props.sources,
+    attachments = props.attachments,
+    approval = props.approval,
+    approvalStatus = props.approvalStatus,
+    suggestions = props.suggestions,
+    createAgentFollowUp = props.createAgentFollowUp,
+    hasSelectedSuggestion = props.hasSelectedSuggestion,
+    isLastMessage = props.isLastMessage;
+  var _useState3 = useState(null),
+    _useState4 = _slicedToArray(_useState3, 2),
+    previewAttachment = _useState4[0],
+    setPreviewAttachment = _useState4[1];
+  var isCurrentUser = role === ChatHistoryRole.USER || user.id === authUser.id.toString();
+  var isAssistant = role === ChatHistoryRole.ASSISTANT || user.id === 'assistant';
+  // Mientras el agente "piensa" (streaming sin texto) no montamos el MessageItem:
+  // un placeholder vacío sumaría otro gap de 36px encima del indicador de actividad.
+  var isStreamingPlaceholder = isStreamingPlaceholderMessageId(id);
+  var streamingText = useStreamingMessage(isStreaming || isStreamingPlaceholder ? id : null);
+  var isActiveStreaming = !!isStreaming || isStreamingPlaceholder;
+  var isThinking = isActiveStreaming && !streamingText;
+  if (isThinking) {
+    return null;
+  }
+  var messageAttachments = attachments && attachments.length > 0 ? attachments : !isAssistant && Array.isArray(sources) ? sources : [];
+  var handleAttachmentClick = function handleAttachmentClick(attachment) {
+    // Permitir previsualización si tiene archivo local o URLs del backend
+    if (attachment.file instanceof File || attachment.originalFile instanceof File || attachment.url_thumbnail || attachment.url_original || attachment.url_file) {
+      setPreviewAttachment(attachment);
+    }
+  };
+  var handleClosePreview = function handleClosePreview() {
+    setPreviewAttachment(null);
+  };
+  var handleAttachmentDownload = /*#__PURE__*/function () {
+    var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(attachment) {
+      var extension, fileName, fileUrl, blobUrl, downloadedFile, link, _t;
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            extension = attachment.name.includes('.') ? '' : ".".concat(attachment.type);
+            fileName = "".concat(attachment.name).concat(extension);
+            fileUrl = attachment.url_original || attachment.url_file || attachment.url_thumbnail;
+            _context.prev = 1;
+            blobUrl = null;
+            if (!fileUrl) {
+              _context.next = 3;
+              break;
+            }
+            _context.next = 2;
+            return downloadFileFromUrl(fileUrl, fileName, attachment.type);
+          case 2:
+            downloadedFile = _context.sent;
+            blobUrl = URL.createObjectURL(downloadedFile);
+            _context.next = 4;
+            break;
+          case 3:
+            if (attachment.file instanceof File) {
+              blobUrl = URL.createObjectURL(attachment.file);
+            }
+          case 4:
+            if (blobUrl) {
+              _context.next = 5;
+              break;
+            }
+            return _context.abrupt("return");
+          case 5:
+            link = document.createElement('a');
+            link.href = blobUrl;
+            link.download = fileName;
+            link.style.display = 'none';
+            document.body.appendChild(link);
+            link.click();
+            setTimeout(function () {
+              document.body.removeChild(link);
+              URL.revokeObjectURL(blobUrl);
+            }, 100);
+            _context.next = 7;
+            break;
+          case 6:
+            _context.prev = 6;
+            _t = _context["catch"](1);
+            console.error('Failed to download attachment', _t);
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[1, 6]]);
+    }));
+    return function handleAttachmentDownload(_x) {
+      return _ref4.apply(this, arguments);
+    };
+  }();
+  if (isChangeProject && options) {
+    return /*#__PURE__*/_jsx(MessageWrapper, {
+      isCurrentUser: isCurrentUser,
+      "data-message-id": id,
+      hasFeedback: false,
+      children: /*#__PURE__*/_jsx(SCMessageItemWrapper, {
+        $isAssistant: isAssistant,
+        children: /*#__PURE__*/_jsx(MessageContentWrapper, {
+          isChangeProject: isChangeProject,
+          message: message,
+          isCurrentUser: isCurrentUser,
+          isError: isError,
+          messageExtraContent: /*#__PURE__*/_jsx(MessageOptions, {
+            options: options,
+            handleSelectOption: handleSelectOption
+          })
+        })
+      })
+    }, id);
+  }
+  var handleFeedbackClick = function handleFeedbackClick(feedback) {
+    var sessionId = id.split('-').filter(function (questionId) {
+      return questionId !== 'answer';
+    }).join('-');
+    handleFeedback === null || handleFeedback === void 0 || handleFeedback(feedback, sessionId);
+  };
+  return /*#__PURE__*/_jsxs(SCMessageItemWrapper, {
+    $isAssistant: isAssistant,
+    children: [/*#__PURE__*/_jsxs(SCMessageItemInner, {
+      children: [!!messageAttachments.length && /*#__PURE__*/_jsx(SCAttachmentsRow, {
+        $isAssistant: isAssistant,
+        children: messageAttachments.map(function (attachment, index) {
+          var _attachment$type, _attachment$name;
+          // Detectar si es un archivo de audio
+          var attachmentType = (attachment === null || attachment === void 0 || (_attachment$type = attachment.type) === null || _attachment$type === void 0 ? void 0 : _attachment$type.toLowerCase()) || '';
+          var attachmentName = (attachment === null || attachment === void 0 || (_attachment$name = attachment.name) === null || _attachment$name === void 0 ? void 0 : _attachment$name.toLowerCase()) || '';
+          var isAudioFile = attachmentType.startsWith('audio/') || ['flac', 'm4a', 'mp3', 'mp4', 'oga', 'ogg', 'wav', 'webm'].includes(attachmentType) || ['.flac', '.m4a', '.mp3', '.mp4', '.oga', '.ogg', '.wav', '.webm'].some(function (ext) {
+            return attachmentName.endsWith(ext);
+          });
+          if (isAudioFile) {
+            return /*#__PURE__*/_jsx(AttachmentCardAudio, {
+              attachment: attachment
+            }, "".concat(attachment.id, "-").concat(attachment.name));
+          }
+          return /*#__PURE__*/_jsx(AttachmentCard, {
+            attachment: attachment,
+            positionIndex: index,
+            onDownload: function onDownload() {
+              return handleAttachmentDownload(attachment);
+            },
+            onClick: function onClick() {
+              return handleAttachmentClick(attachment);
+            }
+          }, "".concat(attachment.id, "-").concat(attachment.name));
+        })
+      }), (!!message || isActiveStreaming) && !(isAssistant && !!messageAttachments.length) && /*#__PURE__*/_jsx(StreamingMessageBody, {
+        message: message !== null && message !== void 0 ? message : '',
+        isStreaming: isActiveStreaming,
+        isCurrentUser: isCurrentUser,
+        isAssistant: isAssistant,
+        isFrontendCancelled: props.isFrontendCancelled,
+        approval: approval,
+        isError: isError,
+        sources: sources,
+        suggestions: suggestions,
+        createAgentFollowUp: createAgentFollowUp,
+        handleFeedbackClick: handleFeedbackClick,
+        disableFeedback: disableFeedback !== null && disableFeedback !== void 0 ? disableFeedback : null,
+        onRetry: handleRetry,
+        handleSuggestionClick: handleSuggestionClick,
+        suggestionsDisabled: isActiveStreaming || !!hasSelectedSuggestion,
+        messageId: id,
+        isLastMessage: isLastMessage
+      }), approval && approval.pending_actions && /*#__PURE__*/_jsx(SCApprovalActionsColumn, {
+        children: /*#__PURE__*/_jsx(ApprovalBox, {
+          actions: approval.pending_actions,
+          status: approvalStatus,
+          onApprove: function onApprove(threadIds) {
+            return handleApprovalDecision(threadIds, 'approve');
+          },
+          onReject: function onReject(threadIds) {
+            return handleApprovalDecision(threadIds, 'reject');
+          },
+          isProjectDeleted: ((_props$projectMetadat = props.projectMetadata) === null || _props$projectMetadat === void 0 ? void 0 : _props$projectMetadat.is_deleted) === true,
+          isExpanded: props.expanded,
+          hitlInstanceId: approval.original_thread_id,
+          warningMessage: approval.warning_message,
+          manualApprovalDetected: approval.manual_approval_detected
+        })
+      })]
+    }), /*#__PURE__*/_jsx(AttachmentPreviewModal, {
+      isOpen: !!previewAttachment,
+      onClose: handleClosePreview,
+      attachment: previewAttachment
+    })]
+  });
+});
+var ChatAIMessagesInner = function ChatAIMessagesInner(_ref5) {
+  var userInitialMessage = _ref5.userInitialMessage,
+    initialChatId = _ref5.initialChatId,
+    onError = _ref5.onError,
+    onSendMessageReady = _ref5.onSendMessageReady,
+    onScrollToBottom = _ref5.onScrollToBottom,
+    attachments = _ref5.attachments,
+    agents = _ref5.agents,
+    expanded = _ref5.expanded;
+  var _useT = useT(),
+    t = _useT.t;
+  var _useGlobalContext = useGlobalContext(),
+    isWebSearchActive = _useGlobalContext.isWebSearchActive,
+    isDeepSearchActive = _useGlobalContext.isDeepSearchActive,
+    agent = _useGlobalContext.agent;
+  var event = useEvent();
+  var authUser = useUser();
+  var messagesRef = useRef(null);
+  var chatInitializedRef = useRef(false);
+  var isLoadingMoreRef = useRef(false);
+  var userScrollingRef = useRef(false);
+  var scrollThresholdRef = useRef(39);
+  var lastScrollTopRef = useRef(0);
+  var showScrollToBottomRef = useRef(false);
+  var scrollRafRef = useRef(null);
+  var wasLoadingMessagesRef = useRef(false);
+  var lastScrolledSessionRef = useRef(null);
+  var _useState5 = useState(false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    showScrollToBottom = _useState6[0],
+    setShowScrollToBottom = _useState6[1];
+  var _useState7 = useState({}),
+    _useState8 = _slicedToArray(_useState7, 2),
+    selectedSuggestionMessageIds = _useState8[0],
+    setSelectedSuggestionMessageIds = _useState8[1];
+  var _useChatManager = useChatManager({
+      chatId: initialChatId || undefined,
+      userInitialMessage: userInitialMessage,
+      onError: onError,
+      attachments: attachments,
+      agents: agents
+    }),
+    messages = _useChatManager.messages,
+    loadingMessages = _useChatManager.loadingMessages,
+    isLoadingMoreMessages = _useChatManager.isLoadingMoreMessages,
+    waitingResponse = _useChatManager.waitingResponse,
+    isWriting = _useChatManager.isWriting,
+    loadingMessage = _useChatManager.loadingMessage,
+    streamActivity = _useChatManager.streamActivity,
+    activeLoadings = _useChatManager.activeLoadings,
+    sendMessage = _useChatManager.sendMessage,
+    retryMessage = _useChatManager.retryMessage,
+    changeProject = _useChatManager.changeProject,
+    handleFeedback = _useChatManager.handleFeedback,
+    handleApprovalDecision = _useChatManager.handleApprovalDecision,
+    initializeChat = _useChatManager.initializeChat,
+    handleScroll = _useChatManager.handleScroll,
+    stopGeneration = _useChatManager.stopGeneration;
+  var handleSelectOption = useCallback(function (option) {
+    changeProject(option);
+  }, [changeProject]);
+  var handleSuggestionClick = useCallback(function (messageId, suggestion) {
+    if (!(suggestion !== null && suggestion !== void 0 && suggestion.trim())) return;
+    if (selectedSuggestionMessageIds[messageId]) return;
+    var isMarketplaceGlobalAgent = isMaiakerAgent(agent);
+    event(EVENTS.aiChatSuggestedAnswer, {
+      agent_type: isMarketplaceGlobalAgent ? 'marketplace' : agent === null || agent === void 0 ? void 0 : agent.type
+    });
+    setSelectedSuggestionMessageIds(function (prev) {
+      return _objectSpread(_objectSpread({}, prev), {}, _defineProperty({}, messageId, true));
+    });
+    var targetMessage = messages.find(function (msg) {
+      return msg.id === messageId;
+    });
+    var isRetrySuggestion = !!(targetMessage !== null && targetMessage !== void 0 && targetMessage.isError) && suggestion === t('chat.retry');
+    if (isRetrySuggestion) {
+      var _lastUserMessage = messages.filter(function (msg) {
+        return msg.role === ChatHistoryRole.USER || msg.user.id === authUser.id.toString();
+      }).at(-1);
+      if (_lastUserMessage !== null && _lastUserMessage !== void 0 && _lastUserMessage.message) {
+        var retryAttachments = Array.isArray(_lastUserMessage.attachments) ? _lastUserMessage.attachments : Array.isArray(_lastUserMessage.sources) ? _lastUserMessage.sources : [];
+        sendMessage(_lastUserMessage.message, retryAttachments);
+        return;
+      }
+    }
+    sendMessage(suggestion);
+  }, [sendMessage, selectedSuggestionMessageIds, event, agent === null || agent === void 0 ? void 0 : agent.entity, agent === null || agent === void 0 ? void 0 : agent.name, agent === null || agent === void 0 ? void 0 : agent.type, messages, t, authUser.id]);
+
+  /**
+   * Actualiza el estado del botón "scroll to bottom" comparando la posición
+   * actual del scroll con el fondo. Usa un ref para evitar `setState` cuando
+   * el valor no cambia.
+   */
+  var updateScrollBottomVisibility = useCallback(function () {
+    var el = messagesRef.current;
+    if (!el) return;
+    var scrollTop = el.scrollTop,
+      scrollHeight = el.scrollHeight,
+      clientHeight = el.clientHeight;
+    var distanceFromBottom = scrollHeight - scrollTop - clientHeight;
+    var shouldShow = distanceFromBottom > 50;
+    if (showScrollToBottomRef.current !== shouldShow) {
+      showScrollToBottomRef.current = shouldShow;
+      setShowScrollToBottom(shouldShow);
+    }
+  }, []);
+
+  /**
+   * Scroll inmediato al fondo (dentro de rAF para coordinar con el paint)
+   * y actualiza la visibilidad del botón. Respeta `skipIfUserScrolling` para
+   * no sobrescribir el scroll manual del usuario durante el streaming.
+   */
+  var scrollToBottomRaf = useCallback(function () {
+    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var _opts$skipIfUserScrol = opts.skipIfUserScrolling,
+      skipIfUserScrolling = _opts$skipIfUserScrol === void 0 ? false : _opts$skipIfUserScrol,
+      _opts$delayMs = opts.delayMs,
+      delayMs = _opts$delayMs === void 0 ? 0 : _opts$delayMs;
+    var run = function run() {
+      requestAnimationFrame(function () {
+        var el = messagesRef.current;
+        if (!el) return;
+        if (skipIfUserScrolling && userScrollingRef.current) return;
+        el.scrollTop = el.scrollHeight;
+        updateScrollBottomVisibility();
+      });
+    };
+    if (delayMs > 0) setTimeout(run, delayMs);else run();
+  }, [updateScrollBottomVisibility]);
+  var handleClickScrollToBottom = useCallback(function () {
+    if (!messagesRef.current) return;
+    messagesRef.current.scrollTo({
+      top: messagesRef.current.scrollHeight,
+      behavior: 'smooth'
+    });
+    // Dar tiempo al smooth-scroll antes de recalcular la visibilidad del botón.
+    setTimeout(updateScrollBottomVisibility, 500);
+  }, [updateScrollBottomVisibility]);
+
+  // Al decidir en el ApprovalBox: el box colapsa (botones -> badge) y el stream
+  // continúa abajo. Reactivar el auto-scroll y seguir el fondo para que la vista
+  // no quede atrás (evita que aparezca la flecha de scroll-to-bottom).
+  var handleApprovalDecisionWithScroll = useCallback(function () {
+    userScrollingRef.current = false;
+    scrollThresholdRef.current = 39;
+    handleApprovalDecision.apply(void 0, arguments);
+    scrollToBottomRaf();
+    scrollToBottomRaf({
+      delayMs: 100
+    });
+  }, [handleApprovalDecision, scrollToBottomRaf]);
+  var handleScrollToBottom = useCallback(function (e) {
+    var container = e.currentTarget;
+    if (scrollRafRef.current !== null) {
+      cancelAnimationFrame(scrollRafRef.current);
+    }
+    scrollRafRef.current = requestAnimationFrame(function () {
+      scrollRafRef.current = null;
+      var scrollTop = container.scrollTop,
+        scrollHeight = container.scrollHeight,
+        clientHeight = container.clientHeight;
+      var isScrollingUp = scrollTop < lastScrollTopRef.current;
+      if (isScrollingUp) {
+        scrollThresholdRef.current = 15;
+      }
+      var isNearBottom = scrollHeight - scrollTop - clientHeight < scrollThresholdRef.current;
+      if (isNearBottom) {
+        scrollThresholdRef.current = 39;
+      }
+      userScrollingRef.current = !isNearBottom;
+      lastScrollTopRef.current = scrollTop;
+      updateScrollBottomVisibility();
+      if (isNearBottom && onScrollToBottom) {
+        onScrollToBottom();
+      }
+      handleScroll(container);
+    });
+  }, [onScrollToBottom, handleScroll, updateScrollBottomVisibility]);
+
+  // refs to stabilize functions and avoid unnecessary re-renders
+  var sendMessageRef = useRef(sendMessage);
+  var stopGenerationRef = useRef(stopGeneration);
+  var onSendMessageReadyRef = useRef(onSendMessageReady);
+  var sendMessageProxyRef = useRef(function (message, attachments, faqId, agentSuggestionId, mentions, fuaId, scId) {
+    return sendMessageRef.current(message, attachments, faqId, agentSuggestionId, mentions, fuaId, scId);
+  });
+  var stopGenerationProxyRef = useRef(function () {
+    return stopGenerationRef.current();
+  });
+
+  // update refs when functions change
+  sendMessageRef.current = sendMessage;
+  stopGenerationRef.current = stopGeneration;
+  onSendMessageReadyRef.current = onSendMessageReady;
+  useEffect(function () {
+    if (onSendMessageReadyRef.current) {
+      onSendMessageReadyRef.current(sendMessageProxyRef.current, stopGenerationProxyRef.current, waitingResponse, isWriting);
+    }
+  }, [waitingResponse, isWriting]);
+  useEffect(function () {
+    isLoadingMoreRef.current = isLoadingMoreMessages;
+  }, [isLoadingMoreMessages]);
+
+  // Cuando el agente empieza a responder, resetear el flag y el umbral para activar el auto-scroll
+  useEffect(function () {
+    if (waitingResponse) {
+      userScrollingRef.current = false;
+      scrollThresholdRef.current = 39;
+    }
+  }, [waitingResponse]);
+  useEffect(function () {
+    if (!chatInitializedRef.current) {
+      chatInitializedRef.current = true;
+      initializeChat();
+    }
+  }, []);
+
+  // Autoscroll mientras el texto del stream crece. El texto se pinta al ritmo
+  // de `useSmoothStreamText` (~60fps), no al ritmo de llegada de tokens del
+  // backend: por eso acá usamos un loop de rAF que compara `scrollHeight`
+  // contra el último valor observado y ajusta solo cuando cambia. Así el
+  // scroll queda perfectamente sincronizado con la animación del texto sin
+  // depender de la cadencia del streamingStore.
+  useEffect(function () {
+    if (!waitingResponse && !isWriting) return undefined;
+    if (!messagesRef.current) return undefined;
+    var rafId = null;
+    var lastHeight = messagesRef.current.scrollHeight;
+    var _tick = function tick() {
+      var el = messagesRef.current;
+      if (!el) {
+        rafId = null;
+        return;
+      }
+      var currentHeight = el.scrollHeight;
+      if (currentHeight !== lastHeight) {
+        lastHeight = currentHeight;
+        if (!userScrollingRef.current) {
+          el.scrollTop = currentHeight;
+        }
+        updateScrollBottomVisibility();
+      }
+      rafId = requestAnimationFrame(_tick);
+    };
+    rafId = requestAnimationFrame(_tick);
+    return function () {
+      if (rafId != null) cancelAnimationFrame(rafId);
+    };
+  }, [waitingResponse, isWriting, updateScrollBottomVisibility]);
+
+  // Al comenzar a esperar la respuesta del backend, scroll inicial al fondo.
+  useEffect(function () {
+    if (waitingResponse && messagesRef.current) {
+      scrollToBottomRaf({
+        skipIfUserScrolling: true
+      });
+    }
+  }, [waitingResponse, scrollToBottomRaf]);
+
+  // Scroll cuando cambian los mensajes: distingue "nuevo mensaje" (agregado)
+  // de "reemplazo" (mismo id/length, ej. feedback o approvalStatus). En
+  // reemplazos solo se recalcula la visibilidad del botón sin forzar scroll.
+  var lastMessageIdRef = useRef(null);
+  var lastMessagesLengthRef = useRef(0);
+
+  // Al cambiar de sesión, resetear estado de scroll manual para no heredar el chat anterior.
+  useEffect(function () {
+    wasLoadingMessagesRef.current = false;
+    lastScrolledSessionRef.current = null;
+    userScrollingRef.current = false;
+    scrollThresholdRef.current = 39;
+    lastScrollTopRef.current = 0;
+    lastMessageIdRef.current = null;
+    lastMessagesLengthRef.current = 0;
+  }, [initialChatId]);
+
+  // Restauración desde cache (sin Loader): bajar al fondo al reabrir sesión visitada.
+  useLayoutEffect(function () {
+    var _messages$id, _messages;
+    if (loadingMessages || !initialChatId || messages.length === 0) return;
+    if (lastScrolledSessionRef.current === initialChatId) return;
+    lastScrolledSessionRef.current = initialChatId;
+    userScrollingRef.current = false;
+    scrollThresholdRef.current = 39;
+    lastMessageIdRef.current = (_messages$id = (_messages = messages[messages.length - 1]) === null || _messages === void 0 ? void 0 : _messages.id) !== null && _messages$id !== void 0 ? _messages$id : null;
+    lastMessagesLengthRef.current = messages.length;
+    scrollToBottomRaf();
+    scrollToBottomRaf({
+      delayMs: 100
+    });
+  }, [initialChatId, loadingMessages, messages.length, messages, scrollToBottomRaf]);
+  useEffect(function () {
+    var _lastMessage$id;
+    if (!messagesRef.current || loadingMessages || isLoadingMoreMessages || isLoadingMoreRef.current) {
+      return;
+    }
+    var lastMessage = messages[messages.length - 1];
+    var lastId = (_lastMessage$id = lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.id) !== null && _lastMessage$id !== void 0 ? _lastMessage$id : null;
+    var prevId = lastMessageIdRef.current;
+    var prevLen = lastMessagesLengthRef.current;
+    lastMessageIdRef.current = lastId;
+    lastMessagesLengthRef.current = messages.length;
+    var isNewMessage = lastId !== prevId || messages.length !== prevLen;
+    if (!isNewMessage) {
+      updateScrollBottomVisibility();
+      return;
+    }
+    var container = messagesRef.current;
+    var isAtBottom = container.scrollHeight - container.scrollTop <= container.clientHeight + 100;
+    var hasInitialMessage = messages.some(function (msg) {
+      return msg.id === 'user-initial-message';
+    });
+    var isApproval = !!lastMessage && (lastMessage.id.startsWith('approval-') || !!lastMessage.approval);
+    var isAnswerOrQuestion = !!lastMessage && (lastMessage.id.startsWith('answer-') || lastMessage.id.startsWith('question-'));
+
+    // Approval: secuencia de scrolls con delay porque el ApprovalBox necesita
+    // un tick para medirse. Scrollea aunque el usuario no esté al fondo si no
+    // está scrolleando manualmente.
+    if (isApproval && (isAtBottom || !userScrollingRef.current)) {
+      scrollToBottomRaf();
+      scrollToBottomRaf();
+      scrollToBottomRaf({
+        delayMs: 100
+      });
+      return;
+    }
+
+    // Nuevos answer/question: scroll si el usuario ya estaba al fondo.
+    if (isAnswerOrQuestion && isAtBottom) {
+      scrollToBottomRaf();
+      return;
+    }
+
+    // Caso borde: cambios de mensajes sin ser nuevo answer/user/approval
+    // pero sí un mensaje nuevo (no el "user-initial-message"). Scrollea.
+    if (!isAnswerOrQuestion && !isApproval && !hasInitialMessage && messages.length > prevLen) {
+      scrollToBottomRaf();
+      return;
+    }
+    updateScrollBottomVisibility();
+  }, [messages, loadingMessages, isLoadingMoreMessages, scrollToBottomRaf, updateScrollBottomVisibility]);
+
+  // Al abrir/cargar una conversación el contenedor se remonta (Loader → lista) con
+  // scrollTop=0. Forzamos ir al fondo al terminar loadMessages, sin afectar paginación hacia arriba.
+  useLayoutEffect(function () {
+    var _messages$id2, _messages2;
+    var justFinishedLoading = wasLoadingMessagesRef.current && !loadingMessages;
+    wasLoadingMessagesRef.current = loadingMessages;
+    if (!justFinishedLoading || messages.length === 0) return;
+    userScrollingRef.current = false;
+    scrollThresholdRef.current = 39;
+    lastMessageIdRef.current = (_messages$id2 = (_messages2 = messages[messages.length - 1]) === null || _messages2 === void 0 ? void 0 : _messages2.id) !== null && _messages$id2 !== void 0 ? _messages$id2 : null;
+    lastMessagesLengthRef.current = messages.length;
+    scrollToBottomRaf();
+    scrollToBottomRaf({
+      delayMs: 100
+    });
+  }, [loadingMessages, messages.length, scrollToBottomRaf]);
+
+  // Obtener el último mensaje del usuario para verificar si tiene attachments
+  var lastUserMessage = messages.filter(function (msg) {
+    return msg.role === ChatHistoryRole.USER || msg.user.id === authUser.id.toString();
+  }).at(-1);
+  var attachmentsCount = (Array.isArray(lastUserMessage === null || lastUserMessage === void 0 ? void 0 : lastUserMessage.attachments) ? lastUserMessage.attachments.length : 0) || (Array.isArray(lastUserMessage === null || lastUserMessage === void 0 ? void 0 : lastUserMessage.sources) ? lastUserMessage.sources.length : 0);
+  var streamLoadingDisplay = resolveStreamLoadingDisplay({
+    streamActivity: streamActivity,
+    loadingMessage: loadingMessage,
+    activeLoadings: activeLoadings || {},
+    waitingResponse: waitingResponse,
+    isWebSearchActive: isWebSearchActive,
+    isDeepSearchActive: isDeepSearchActive,
+    hasAttachments: Boolean(attachmentsCount),
+    attachmentsCount: attachmentsCount,
+    t: t
+  });
+  var isScrollOnParent = !!expanded;
+  var isMarketplaceGlobalAgent = isMaiakerAgent(agent);
+
+  // Al expandir/contraer el modal el ref pasa a otro contenedor (scrollTop se resetea a 0).
+  // Restaurar la posición de scroll antes del paint para evitar que la conversación salte arriba.
+  var expandedRef = useRef(expanded);
+  useLayoutEffect(function () {
+    if (expandedRef.current !== expanded && messagesRef.current) {
+      var savedScrollTop = lastScrollTopRef.current;
+      messagesRef.current.scrollTop = savedScrollTop;
+      expandedRef.current = expanded;
+    } else {
+      expandedRef.current = expanded;
+    }
+  }, [expanded]);
+  if (loadingMessages) {
+    return /*#__PURE__*/_jsx(Fade, {
+      fill: true,
+      children: /*#__PURE__*/_jsx(Loader, {})
+    });
+  }
+  var messagesContent = /*#__PURE__*/_jsxs(_Fragment, {
+    children: [isLoadingMoreMessages && /*#__PURE__*/_jsx(LoadingText, {
+      text: t('chat.loadingMore')
+    }), /*#__PURE__*/_jsx(_Fragment, {
+      children: messages.map(function (message, index) {
+        var _message$attachments, _message$sources, _message$project, _message$id;
+        var isAssistantMessage = message.role === ChatHistoryRole.ASSISTANT || message.user.id === 'assistant';
+        var isLastMessage = index === messages.length - 1;
+        var isStreamingPlaceholder = isAssistantMessage && isLastMessage && isStreamingPlaceholderMessageId(message.id);
+        var isStreaming = isStreamingPlaceholder && (waitingResponse || isWriting);
+
+        // No filtrar el placeholder del mensaje en streaming: su texto vive
+        // en el streamingStore y `message.message` es '' hasta el complete.
+        if (!isStreamingPlaceholder && !isStreaming && !((_message$attachments = message.attachments) !== null && _message$attachments !== void 0 && _message$attachments.length || (_message$sources = message.sources) !== null && _message$sources !== void 0 && _message$sources.length) && !message.message && !((_message$project = message.project) !== null && _message$project !== void 0 && _message$project.name) && !message.approval) return null;
+        var messageFeedback = (message === null || message === void 0 ? void 0 : message.wasHelpful) === undefined || message.wasHelpful === null ? null : message.wasHelpful ? Feedback.THUMBS_UP : Feedback.THUMBS_DOWN;
+
+        // Key estable: solo message.id para evitar remount durante streaming (message.date puede cambiar)
+        var messageKey = (_message$id = message.id) !== null && _message$id !== void 0 ? _message$id : "msg-".concat(index);
+        var turnId = resolveRetryTurnId(message);
+        var userMessageForRetry = findUserMessageForRetry(messages, message);
+        var canRetry = !!userMessageForRetry && !isStreaming && !message.isError && !message.approval && (message.isFrontendCancelled || !message.is_cancelled && !!turnId);
+        return /*#__PURE__*/_createElement(MessageItem, _objectSpread(_objectSpread({}, message), {}, {
+          key: messageKey,
+          authUser: authUser,
+          handleSelectOption: handleSelectOption,
+          handleFeedback: handleFeedback,
+          handleApprovalDecision: handleApprovalDecisionWithScroll,
+          handleSuggestionClick: handleSuggestionClick,
+          handleRetry: canRetry ? function () {
+            return retryMessage(message);
+          } : undefined,
+          hasSelectedSuggestion: !!selectedSuggestionMessageIds[message.id],
+          disableFeedback: messageFeedback,
+          isStreaming: isStreaming,
+          isLastMessage: isLastMessage,
+          expanded: expanded
+        }));
+      })
+    }), streamLoadingDisplay && /*#__PURE__*/_jsx(SCLoadingMessagesColumn, {
+      children: /*#__PURE__*/_jsx(AgentActivityIndicator, {
+        activity: streamLoadingDisplay
+      })
+    })]
+  });
+  return /*#__PURE__*/_jsxs(SCMessagesOuter, {
+    $scrollOnParent: isScrollOnParent,
+    children: [isScrollOnParent ? /*#__PURE__*/_jsx(SCMessagesScroll, {
+      ref: messagesRef,
+      onScroll: handleScrollToBottom,
+      children: /*#__PURE__*/_jsx(SCMessagesInner, {
+        $scrollOnParent: isScrollOnParent,
+        $isMarketplaceGlobal: isMarketplaceGlobalAgent,
+        children: messagesContent
+      })
+    }) : /*#__PURE__*/_jsx(SCMessagesInner, {
+      ref: messagesRef,
+      onScroll: handleScrollToBottom,
+      $scrollOnParent: false,
+      $isMarketplaceGlobal: isMarketplaceGlobalAgent,
+      children: messagesContent
+    }), showScrollToBottom && /*#__PURE__*/_jsx(ScrollToBottomButton, {
+      type: "button",
+      onClick: handleClickScrollToBottom,
+      children: /*#__PURE__*/_jsx(ArrowSmallDown, {
+        color: "#666",
+        width: "20px",
+        height: "20px"
+      })
+    })]
+  });
+};
+export var ChatAIMessages = /*#__PURE__*/React.memo(ChatAIMessagesInner);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","memo","useCallback","useEffect","useLayoutEffect","useRef","useState","createElement","_createElement","ArrowSmallDown","AttachmentCard","ApprovalBox","AttachmentPreviewModal","AttachmentCardAudio","MaiaStreamdown","ChatHistoryRole","renderTextWithMentions","hasInlineMarkers","isMaiakerAgent","useUser","useT","useChatManager","useSmoothStreamText","useStreamingMessage","LoadingText","AgentActivityIndicator","isStreamingPlaceholderMessageId","resolveStreamLoadingDisplay","resolveRetryTurnId","findUserMessageForRetry","Loader","Fade","MessageFromUser","MessageFromOther","MessageContentFromUser","MessageContentFromOther","MessageFeedback","SCCAIMessageWrapper","ScrollToBottomButton","SCMessagesOuter","SCMessagesScroll","SCMessagesInner","SCLoadingMessagesColumn","SCOptionsList","SCOptionItem","SCMessageItemWrapper","SCMessageItemInner","SCAttachmentsRow","SCApprovalActionsColumn","Feedback","useGlobalContext","EntityLinkCustomLink","getEntityLinkWrapperClassName","ChatAISuggestions","ChatAICreateAgentActions","EVENTS","useEvent","downloadFileFromUrl","jsx","_jsx","Fragment","_Fragment","jsxs","_jsxs","MessageWrapper","_ref","isCurrentUser","children","props","_objectWithoutProperties","_excluded","MessageComponent","_objectSpread","MessageContentWrapper","_ref2","_excluded2","MessageContentComponent","MessageOptions","_ref3","options","handleSelectOption","_useState","_useState2","_slicedToArray","selectedOption","setSelectedOption","handleSelect","option","map","$hasSelection","$dimmed","id","onClick","name","StreamingMessageBody","_props$createAgentFol","_props$suggestions","streamingText","isStreaming","messageId","rawText","message","winFlags","window","displayText","enabled","maxCharsPerFrame","snapToWordBoundary","streamLagMs","targetLagMs","streamAdapt","adaptToBackendRate","streamBufferMs","targetBufferMs","streamMinBuffer","minBufferChars","streamWarmupMs","warmupMs","createAgentActionsAgentId","createAgentFollowUp","agentId","hasMentions","mentionNodes","isFrontendCancelled","className","style","display","variant","components","a","isAnimating","isAssistant","isError","approval","onRetry","content","sources","undefined","handleFeedback","handleFeedbackClick","disableFeedback","suggestions","length","onSelectSuggestion","suggestion","handleSuggestionClick","disabled","suggestionsDisabled","hidden","isLastMessage","MessageItem","_props$projectMetadat","user","authUser","isChangeProject","handleApprovalDecision","handleRetry","role","attachments","approvalStatus","hasSelectedSuggestion","_useState3","_useState4","previewAttachment","setPreviewAttachment","USER","toString","ASSISTANT","isStreamingPlaceholder","isActiveStreaming","isThinking","messageAttachments","Array","isArray","handleAttachmentClick","attachment","file","File","originalFile","url_thumbnail","url_original","url_file","handleClosePreview","handleAttachmentDownload","_ref4","_asyncToGenerator","_regeneratorRuntime","mark","_callee","extension","fileName","fileUrl","blobUrl","downloadedFile","link","_t","wrap","_context","prev","next","includes","concat","type","sent","URL","createObjectURL","abrupt","document","href","download","body","appendChild","click","setTimeout","removeChild","revokeObjectURL","console","error","stop","_x","apply","arguments","hasFeedback","$isAssistant","messageExtraContent","feedback","sessionId","split","filter","questionId","join","index","_attachment$type","_attachment$name","attachmentType","toLowerCase","attachmentName","isAudioFile","startsWith","some","ext","endsWith","positionIndex","onDownload","pending_actions","actions","status","onApprove","threadIds","onReject","isProjectDeleted","projectMetadata","is_deleted","isExpanded","expanded","hitlInstanceId","original_thread_id","warningMessage","warning_message","manualApprovalDetected","manual_approval_detected","isOpen","onClose","ChatAIMessagesInner","_ref5","userInitialMessage","initialChatId","onError","onSendMessageReady","onScrollToBottom","agents","_useT","t","_useGlobalContext","isWebSearchActive","isDeepSearchActive","agent","event","messagesRef","chatInitializedRef","isLoadingMoreRef","userScrollingRef","scrollThresholdRef","lastScrollTopRef","showScrollToBottomRef","scrollRafRef","wasLoadingMessagesRef","lastScrolledSessionRef","_useState5","_useState6","showScrollToBottom","setShowScrollToBottom","_useState7","_useState8","selectedSuggestionMessageIds","setSelectedSuggestionMessageIds","_useChatManager","chatId","messages","loadingMessages","isLoadingMoreMessages","waitingResponse","isWriting","loadingMessage","streamActivity","activeLoadings","sendMessage","retryMessage","changeProject","initializeChat","handleScroll","stopGeneration","trim","isMarketplaceGlobalAgent","aiChatSuggestedAnswer","agent_type","_defineProperty","targetMessage","find","msg","isRetrySuggestion","lastUserMessage","at","retryAttachments","entity","updateScrollBottomVisibility","el","current","scrollTop","scrollHeight","clientHeight","distanceFromBottom","shouldShow","scrollToBottomRaf","opts","_opts$skipIfUserScrol","skipIfUserScrolling","_opts$delayMs","delayMs","run","requestAnimationFrame","handleClickScrollToBottom","scrollTo","top","behavior","handleApprovalDecisionWithScroll","handleScrollToBottom","e","container","currentTarget","cancelAnimationFrame","isScrollingUp","isNearBottom","sendMessageRef","stopGenerationRef","onSendMessageReadyRef","sendMessageProxyRef","faqId","agentSuggestionId","mentions","fuaId","scId","stopGenerationProxyRef","rafId","lastHeight","tick","currentHeight","lastMessageIdRef","lastMessagesLengthRef","_messages$id","_messages","_lastMessage$id","lastMessage","lastId","prevId","prevLen","isNewMessage","isAtBottom","hasInitialMessage","isApproval","isAnswerOrQuestion","_messages$id2","_messages2","justFinishedLoading","attachmentsCount","streamLoadingDisplay","hasAttachments","Boolean","isScrollOnParent","expandedRef","savedScrollTop","fill","messagesContent","text","_message$attachments","_message$sources","_message$project","_message$id","isAssistantMessage","project","messageFeedback","wasHelpful","THUMBS_UP","THUMBS_DOWN","messageKey","turnId","userMessageForRetry","canRetry","is_cancelled","key","activity","$scrollOnParent","ref","onScroll","$isMarketplaceGlobal","color","width","height","ChatAIMessages"],"sources":["../../../../src/components/molecules/ChatAIMessages/ChatAIMessages.tsx"],"sourcesContent":["/* eslint-disable import/no-extraneous-dependencies */\n/* eslint-disable @typescript-eslint/indent */\n/* eslint-disable react/no-unstable-nested-components */\n/* eslint-disable @typescript-eslint/no-shadow */\n/* eslint-disable no-nested-ternary */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable no-undef */\n/* eslint-disable react/function-component-definition */\n/* eslint-disable react/require-default-props */\n/* eslint-disable jsx-a11y/click-events-have-key-events */\n/* eslint-disable jsx-a11y/no-static-element-interactions */\nimport React, { FC, memo, ReactNode, useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react'\nimport { ArrowSmallDown } from '@projectcor/icons/lib/components/ArrowSmallDown'\n\nimport { AttachmentCard } from '../../atoms/AttachmentCard/AttachmentCard'\nimport { ApprovalBox } from '../../atoms/ApprovalBox/ApprovalBox'\nimport { AttachmentPreviewModal } from '../../atoms/AttachmentPreviewModal'\nimport { AttachmentCardAudio } from '../../atoms/AttachmentCard/AttachmentCardAudio'\nimport { MaiaStreamdown } from '../../atoms/MaiaStreamdown'\nimport type { MaiaStreamdownProps } from '../../atoms/MaiaStreamdown'\nimport { MAIAMessageProps } from '../../atoms/MAIAMessage/MAIAMessage.interfaces'\nimport { ChatMessage, ChatHistoryRole } from '../../../types/Chat'\nimport { renderTextWithMentions, hasInlineMarkers } from '../../../utils/renderContextMentions'\n\nimport { isMaiakerAgent } from '../../../utils/agentDisplayName'\nimport { CORUser, useUser } from '../../../context/cor-user'\n\nimport { useT } from '../../../hooks/useT'\nimport { useChatManager } from '../../../hooks/useChatManager/useChatManager'\nimport { useSmoothStreamText } from '../../../hooks/useSmoothStreamText'\nimport { useStreamingMessage } from '../../../hooks/useStreamingMessage'\n\nimport { LoadingText } from '../../atoms/LoadingText'\nimport { AgentActivityIndicator } from '../../atoms/AgentActivityIndicator'\nimport { isStreamingPlaceholderMessageId, resolveStreamLoadingDisplay } from '../../../utils/streamActivityMessages'\nimport { resolveRetryTurnId, findUserMessageForRetry } from '../../../utils/retryCompletion'\nimport { Loader } from '../../atoms/Loader'\nimport { Fade } from '../../atoms/Fade'\n\nimport { Project } from '../../../types/Project'\n\nimport { MessageFromUser, MessageFromOther, MessageContentFromUser, MessageContentFromOther } from './styles'\nimport { MessageFeedback } from '../MessageFeedback'\nimport {\n  SCCAIMessageWrapper,\n  ScrollToBottomButton,\n  SCMessagesOuter,\n  SCMessagesScroll,\n  SCMessagesInner,\n  SCLoadingMessagesColumn,\n  SCOptionsList,\n  SCOptionItem,\n  SCMessageItemWrapper,\n  SCMessageItemInner,\n  SCAttachmentsRow,\n  SCApprovalActionsColumn,\n} from './newStyles'\nimport { Feedback } from '../MessageFeedback/MessageFeedback'\nimport { useGlobalContext } from '../../../context/global-context'\nimport { Agent } from '../../../types/agent'\nimport { AttachmentFile } from '../ChatFooter/ChatFooter'\nimport { ContextMention } from '../../../types/contextMention'\nimport { EntityLinkCustomLink, getEntityLinkWrapperClassName } from '../../../utils/entityLinkRender'\nimport { ChatAISuggestions } from './ChatAISuggestions'\nimport { ChatAICreateAgentActions } from './ChatAICreateAgentActions'\nimport { EVENTS, useEvent } from '../../../hooks/useEvent'\nimport { downloadFileFromUrl } from '../../../utils/fileDownloadHelper'\n\ntype ChatAIMessagesProps = {\n  userInitialMessage: {\n    message: string\n    attachments: AttachmentFile[]\n    faqId?: string\n    agentSuggestionId?: string\n    mentions?: ContextMention[]\n    fuaId?: string\n    scId?: string\n  }\n  initialChatId: string | null\n  onError: () => void\n  onSendMessageReady?: (\n    sendMessage: (\n      message: string,\n      attachments?: AttachmentFile[],\n      faqId?: string,\n      agentSuggestionId?: string,\n      mentions?: ContextMention[],\n      fuaId?: string,\n      scId?: string\n    ) => void,\n    stopGeneration: () => void,\n    isStreaming: boolean,\n    isWriting: boolean\n  ) => void\n  isDisabled?: boolean\n  onScrollToBottom?: () => void\n  attachments?: AttachmentFile[]\n  agents?: Agent[]\n  expanded?: boolean\n}\n\ntype MessageItemProps = ChatMessage & {\n  authUser: CORUser\n  handleSelectOption: (option: Project) => void\n  handleSuggestionClick: (messageId: string, suggestion: string) => void\n  hasSelectedSuggestion?: boolean\n  handleFeedback: (feedback: Feedback, chatMessageId: string) => void\n  handleApprovalDecision: (threadIds: string[], decision: 'approve' | 'reject') => void\n  handleRetry?: () => void\n  disableFeedback?: Feedback | null\n  sources?: any\n  attachments?: AttachmentFile[]\n  isStreaming?: boolean\n  isLastMessage?: boolean\n  expanded?: boolean\n}\n\ninterface MessageWrapperProps {\n  isCurrentUser: boolean\n  children: ReactNode\n  'data-message-id'?: string\n  hasFeedback?: boolean\n}\n\ntype MessageContentWrapperProps = MAIAMessageProps & {\n  isCurrentUser: boolean\n  isError?: boolean\n  isChangeProject?: boolean\n}\n\nconst MessageWrapper: FC<MessageWrapperProps> = ({ isCurrentUser, children, ...props }) => {\n  const MessageComponent = isCurrentUser ? MessageFromUser : MessageFromOther\n  return <MessageComponent {...props}>{children}</MessageComponent>\n}\n\nconst MessageContentWrapper: FC<MessageContentWrapperProps> = ({ isCurrentUser, ...props }) => {\n  const MessageContentComponent = isCurrentUser ? MessageContentFromUser : MessageContentFromOther\n  return <MessageContentComponent {...props} />\n}\n\nfunction MessageOptions({\n  options,\n  handleSelectOption,\n}: {\n  options: Project[] | null\n  handleSelectOption: (option: Project) => void\n}) {\n  const [selectedOption, setSelectedOption] = useState<Project | null>(null)\n\n  const handleSelect = (option: Project) => {\n    if (selectedOption) return\n    setSelectedOption(option)\n    handleSelectOption(option)\n  }\n\n  return (\n    <SCOptionsList>\n      {(options || []).map(option => (\n        <SCOptionItem\n          $hasSelection={!!selectedOption}\n          $dimmed={!!selectedOption && selectedOption?.id !== option.id}\n          onClick={() => handleSelect(option)}\n          key={option.id}\n        >\n          {option.name}\n        </SCOptionItem>\n      ))}\n    </SCOptionsList>\n  )\n}\n\n/** Solo este componente re-renderiza cuando cambia el texto en streaming (lee del context). */\nconst StreamingMessageBody = memo(\n  (props: {\n    message: string\n    isStreaming: boolean\n    isCurrentUser: boolean\n    isAssistant: boolean\n    isFrontendCancelled?: boolean\n    approval?: MessageItemProps['approval']\n    isError?: boolean\n    sources?: MessageItemProps['sources']\n    suggestions?: string[] | null\n    createAgentFollowUp?: { agentId: string } | null\n    handleFeedbackClick: (f: Feedback) => void\n    disableFeedback: Feedback | null\n    onRetry?: () => void\n    handleSuggestionClick: (messageId: string, suggestion: string) => void\n    suggestionsDisabled?: boolean\n    messageId: string\n    isLastMessage?: boolean\n  }) => {\n    // Texto del stream: solo se lee del store cuando este mensaje es el\n    // que está en streaming. useSyncExternalStore aísla el re-render a\n    // este componente, sin tocar el resto del árbol.\n    const streamingText = useStreamingMessage(props.isStreaming ? props.messageId : null)\n    const rawText = props.isStreaming ? streamingText : props.message\n    // Smooth streaming: desacopla la cadencia del backend del render.\n    // Durante el streaming libera chars a ritmo constante vía rAF; cuando\n    // termina, muestra el texto final al instante (sin animación residual).\n    // Los defaults del hook se ajustaron empíricamente en staging; aun así\n    // se exponen flags de runtime (window.*) para poder tunear sin recompilar\n    // si algún backend presenta una cadencia muy distinta en producción.\n    //   window.streamAdapt = false      // desactiva adaptación al backend\n    //   window.streamBufferMs = 600     // colchón objetivo (ms)\n    //   window.streamLagMs = 450        // lag máximo base (ms)\n    //   window.streamMinBuffer = 70     // piso del colchón en chars\n    //   window.streamWarmupMs = 400     // warmup inicial (ms)\n    const winFlags =\n      typeof window !== 'undefined'\n        ? (window as unknown as {\n            streamAdapt?: boolean\n            streamBufferMs?: number\n            streamLagMs?: number\n            streamMinBuffer?: number\n            streamWarmupMs?: number\n          })\n        : {}\n    const displayText = useSmoothStreamText(rawText, {\n      enabled: !!props.isStreaming,\n      maxCharsPerFrame: 24,\n      snapToWordBoundary: true,\n      ...(winFlags.streamLagMs != null && { targetLagMs: winFlags.streamLagMs }),\n      ...(winFlags.streamAdapt != null && { adaptToBackendRate: winFlags.streamAdapt }),\n      ...(winFlags.streamBufferMs != null && { targetBufferMs: winFlags.streamBufferMs }),\n      ...(winFlags.streamMinBuffer != null && { minBufferChars: winFlags.streamMinBuffer }),\n      ...(winFlags.streamWarmupMs != null && { warmupMs: winFlags.streamWarmupMs }),\n    })\n    const createAgentActionsAgentId = props.createAgentFollowUp?.agentId\n\n    if (!displayText && !props.isStreaming) return null\n    const hasMentions = hasInlineMarkers(displayText)\n    const mentionNodes = hasMentions ? renderTextWithMentions(displayText) : null\n    return (\n      <>\n        <SCCAIMessageWrapper\n          isCurrentUser={props.isCurrentUser}\n          isFrontendCancelled={props.isFrontendCancelled}\n          className={getEntityLinkWrapperClassName(displayText)}\n        >\n          {hasMentions && mentionNodes ? (\n            // Si hay mentions, renderizar directamente (sin markdown en el mismo párrafo)\n            <span style={{ display: 'inline' }}>{mentionNodes}</span>\n          ) : (\n            // Sin mentions, pasar a Streamdown para markdown support\n            <MaiaStreamdown\n              variant=\"chat\"\n              isCurrentUser={props.isCurrentUser}\n              isFrontendCancelled={props.isFrontendCancelled}\n              components={{ a: EntityLinkCustomLink } as MaiaStreamdownProps['components']}\n              isAnimating={!!props.isStreaming}\n            >\n              {displayText}\n            </MaiaStreamdown>\n          )}\n        </SCCAIMessageWrapper>\n        {props.isAssistant &&\n          !props.isError &&\n          !props.approval &&\n          !props.isStreaming &&\n          (!props.isFrontendCancelled || !!props.onRetry) && (\n            <MessageFeedback\n              content={displayText}\n              sources={props.isFrontendCancelled ? undefined : props.sources}\n              handleFeedback={props.isFrontendCancelled ? undefined : props.handleFeedbackClick}\n              disableFeedback={props.disableFeedback}\n              onRetry={props.onRetry}\n            />\n          )}\n        {props.isAssistant &&\n          !props.isFrontendCancelled &&\n          !props.approval &&\n          (!props.isError || props.suggestions?.length) && (\n            <ChatAISuggestions\n              suggestions={props.suggestions || []}\n              onSelectSuggestion={suggestion => props.handleSuggestionClick(props.messageId, suggestion)}\n              disabled={props.suggestionsDisabled}\n              hidden={!!props.isStreaming || !props.isLastMessage || !!props.suggestionsDisabled}\n            />\n          )}\n        {props.isAssistant &&\n          !props.isError &&\n          !props.isFrontendCancelled &&\n          !props.approval &&\n          !!createAgentActionsAgentId && (\n            <ChatAICreateAgentActions\n              agentId={createAgentActionsAgentId}\n              disabled={props.suggestionsDisabled}\n              hidden={!!props.isStreaming || !props.isLastMessage || !!props.suggestionsDisabled}\n            />\n          )}\n      </>\n    )\n  }\n)\n\nconst MessageItem = memo((props: MessageItemProps) => {\n  const {\n    id,\n    user,\n    message,\n    isStreaming,\n    isError,\n    authUser,\n    options,\n    isChangeProject,\n    handleSelectOption,\n    handleSuggestionClick,\n    handleFeedback,\n    handleApprovalDecision,\n    disableFeedback,\n    handleRetry,\n    role,\n    sources,\n    attachments,\n    approval,\n    approvalStatus,\n    suggestions,\n    createAgentFollowUp,\n    hasSelectedSuggestion,\n    isLastMessage,\n  } = props\n\n  const [previewAttachment, setPreviewAttachment] = useState<AttachmentFile | null>(null)\n  const isCurrentUser = role === ChatHistoryRole.USER || user.id === authUser.id.toString()\n  const isAssistant = role === ChatHistoryRole.ASSISTANT || user.id === 'assistant'\n  // Mientras el agente \"piensa\" (streaming sin texto) no montamos el MessageItem:\n  // un placeholder vacío sumaría otro gap de 36px encima del indicador de actividad.\n  const isStreamingPlaceholder = isStreamingPlaceholderMessageId(id)\n  const streamingText = useStreamingMessage(isStreaming || isStreamingPlaceholder ? id : null)\n  const isActiveStreaming = !!isStreaming || isStreamingPlaceholder\n  const isThinking = isActiveStreaming && !streamingText\n  if (isThinking) {\n    return null\n  }\n  const messageAttachments =\n    attachments && attachments.length > 0\n      ? attachments\n      : !isAssistant && Array.isArray(sources)\n        ? (sources as AttachmentFile[])\n        : []\n\n  const handleAttachmentClick = (attachment: AttachmentFile) => {\n    // Permitir previsualización si tiene archivo local o URLs del backend\n    if (\n      attachment.file instanceof File ||\n      attachment.originalFile instanceof File ||\n      attachment.url_thumbnail ||\n      attachment.url_original ||\n      attachment.url_file\n    ) {\n      setPreviewAttachment(attachment)\n    }\n  }\n\n  const handleClosePreview = () => {\n    setPreviewAttachment(null)\n  }\n\n  const handleAttachmentDownload = async (attachment: AttachmentFile) => {\n    const extension = attachment.name.includes('.') ? '' : `.${attachment.type}`\n    const fileName = `${attachment.name}${extension}`\n    const fileUrl = attachment.url_original || attachment.url_file || attachment.url_thumbnail\n\n    try {\n      let blobUrl: string | null = null\n\n      if (fileUrl) {\n        const downloadedFile = await downloadFileFromUrl(fileUrl, fileName, attachment.type)\n        blobUrl = URL.createObjectURL(downloadedFile)\n      } else if (attachment.file instanceof File) {\n        blobUrl = URL.createObjectURL(attachment.file)\n      }\n\n      if (!blobUrl) return\n\n      const link = document.createElement('a')\n      link.href = blobUrl\n      link.download = fileName\n      link.style.display = 'none'\n      document.body.appendChild(link)\n      link.click()\n\n      setTimeout(() => {\n        document.body.removeChild(link)\n        URL.revokeObjectURL(blobUrl)\n      }, 100)\n    } catch (error) {\n      console.error('Failed to download attachment', error)\n    }\n  }\n\n  if (isChangeProject && options) {\n    return (\n      <MessageWrapper key={id} isCurrentUser={isCurrentUser} data-message-id={id} hasFeedback={false}>\n        <SCMessageItemWrapper $isAssistant={isAssistant}>\n          <MessageContentWrapper\n            isChangeProject={isChangeProject}\n            message={message}\n            isCurrentUser={isCurrentUser}\n            isError={isError}\n            messageExtraContent={<MessageOptions options={options as any} handleSelectOption={handleSelectOption} />}\n          />\n        </SCMessageItemWrapper>\n      </MessageWrapper>\n    )\n  }\n\n  const handleFeedbackClick = (feedback: Feedback) => {\n    const sessionId = id\n      .split('-')\n      .filter(questionId => questionId !== 'answer')\n      .join('-')\n    handleFeedback?.(feedback, sessionId)\n  }\n\n  return (\n    <SCMessageItemWrapper $isAssistant={isAssistant}>\n      <SCMessageItemInner>\n        {!!messageAttachments.length && (\n          <SCAttachmentsRow $isAssistant={isAssistant}>\n            {messageAttachments.map((attachment, index) => {\n              // Detectar si es un archivo de audio\n              const attachmentType = attachment?.type?.toLowerCase() || ''\n              const attachmentName = attachment?.name?.toLowerCase() || ''\n              const isAudioFile =\n                attachmentType.startsWith('audio/') ||\n                ['flac', 'm4a', 'mp3', 'mp4', 'oga', 'ogg', 'wav', 'webm'].includes(attachmentType) ||\n                ['.flac', '.m4a', '.mp3', '.mp4', '.oga', '.ogg', '.wav', '.webm'].some(ext =>\n                  attachmentName.endsWith(ext)\n                )\n\n              if (isAudioFile) {\n                return <AttachmentCardAudio key={`${attachment.id}-${attachment.name}`} attachment={attachment} />\n              }\n\n              return (\n                <AttachmentCard\n                  key={`${attachment.id}-${attachment.name}`}\n                  attachment={attachment}\n                  positionIndex={index}\n                  onDownload={() => handleAttachmentDownload(attachment)}\n                  onClick={() => handleAttachmentClick(attachment)}\n                />\n              )\n            })}\n          </SCAttachmentsRow>\n        )}\n        {(!!message || isActiveStreaming) && !(isAssistant && !!messageAttachments.length) && (\n          <StreamingMessageBody\n            message={message ?? ''}\n            isStreaming={isActiveStreaming}\n            isCurrentUser={isCurrentUser}\n            isAssistant={isAssistant}\n            isFrontendCancelled={props.isFrontendCancelled}\n            approval={approval}\n            isError={isError}\n            sources={sources}\n            suggestions={suggestions}\n            createAgentFollowUp={createAgentFollowUp}\n            handleFeedbackClick={handleFeedbackClick}\n            disableFeedback={disableFeedback ?? null}\n            onRetry={handleRetry}\n            handleSuggestionClick={handleSuggestionClick}\n            suggestionsDisabled={isActiveStreaming || !!hasSelectedSuggestion}\n            messageId={id}\n            isLastMessage={isLastMessage}\n          />\n        )}\n        {approval && approval.pending_actions && (\n          <SCApprovalActionsColumn>\n            <ApprovalBox\n              actions={approval.pending_actions}\n              status={approvalStatus}\n              onApprove={threadIds => handleApprovalDecision(threadIds, 'approve')}\n              onReject={threadIds => handleApprovalDecision(threadIds, 'reject')}\n              isProjectDeleted={props.projectMetadata?.is_deleted === true}\n              isExpanded={props.expanded}\n              hitlInstanceId={approval.original_thread_id}\n              warningMessage={approval.warning_message}\n              manualApprovalDetected={approval.manual_approval_detected}\n            />\n          </SCApprovalActionsColumn>\n        )}\n      </SCMessageItemInner>\n      <AttachmentPreviewModal\n        isOpen={!!previewAttachment}\n        onClose={handleClosePreview}\n        attachment={previewAttachment}\n      />\n    </SCMessageItemWrapper>\n  )\n})\n\nconst ChatAIMessagesInner = ({\n  userInitialMessage,\n  initialChatId,\n  onError,\n  onSendMessageReady,\n  onScrollToBottom,\n  attachments,\n  agents,\n  expanded,\n}: ChatAIMessagesProps) => {\n  const { t } = useT()\n  const { isWebSearchActive, isDeepSearchActive, agent } = useGlobalContext()\n  const event = useEvent()\n  const authUser = useUser()\n  const messagesRef = useRef<HTMLDivElement>(null)\n  const chatInitializedRef = useRef(false)\n  const isLoadingMoreRef = useRef(false)\n  const userScrollingRef = useRef(false)\n  const scrollThresholdRef = useRef(39)\n  const lastScrollTopRef = useRef(0)\n  const showScrollToBottomRef = useRef(false)\n  const scrollRafRef = useRef<number | null>(null)\n  const wasLoadingMessagesRef = useRef(false)\n  const lastScrolledSessionRef = useRef<string | null>(null)\n  const [showScrollToBottom, setShowScrollToBottom] = useState(false)\n  const [selectedSuggestionMessageIds, setSelectedSuggestionMessageIds] = useState<Record<string, boolean>>({})\n\n  const {\n    messages,\n    loadingMessages,\n    isLoadingMoreMessages,\n    waitingResponse,\n    isWriting,\n    loadingMessage,\n    streamActivity,\n    activeLoadings,\n    sendMessage,\n    retryMessage,\n    changeProject,\n    handleFeedback,\n    handleApprovalDecision,\n    initializeChat,\n    handleScroll,\n    stopGeneration,\n  } = useChatManager({\n    chatId: initialChatId || undefined,\n    userInitialMessage,\n    onError,\n    attachments,\n    agents,\n  })\n\n  const handleSelectOption = useCallback(\n    (option: Project) => {\n      changeProject(option)\n    },\n    [changeProject]\n  )\n\n  const handleSuggestionClick = useCallback(\n    (messageId: string, suggestion: string) => {\n      if (!suggestion?.trim()) return\n      if (selectedSuggestionMessageIds[messageId]) return\n      const isMarketplaceGlobalAgent = isMaiakerAgent(agent)\n      event(EVENTS.aiChatSuggestedAnswer, {\n        agent_type: isMarketplaceGlobalAgent ? 'marketplace' : agent?.type,\n      })\n      setSelectedSuggestionMessageIds(prev => ({ ...prev, [messageId]: true }))\n\n      const targetMessage = messages.find(msg => msg.id === messageId)\n      const isRetrySuggestion = !!targetMessage?.isError && suggestion === t('chat.retry')\n      if (isRetrySuggestion) {\n        const lastUserMessage = messages\n          .filter(msg => msg.role === ChatHistoryRole.USER || msg.user.id === authUser.id.toString())\n          .at(-1)\n        if (lastUserMessage?.message) {\n          const retryAttachments = Array.isArray(lastUserMessage.attachments)\n            ? lastUserMessage.attachments\n            : Array.isArray(lastUserMessage.sources)\n              ? lastUserMessage.sources\n              : []\n          sendMessage(lastUserMessage.message, retryAttachments)\n          return\n        }\n      }\n\n      sendMessage(suggestion)\n    },\n    [\n      sendMessage,\n      selectedSuggestionMessageIds,\n      event,\n      agent?.entity,\n      agent?.name,\n      agent?.type,\n      messages,\n      t,\n      authUser.id,\n    ]\n  )\n\n  /**\n   * Actualiza el estado del botón \"scroll to bottom\" comparando la posición\n   * actual del scroll con el fondo. Usa un ref para evitar `setState` cuando\n   * el valor no cambia.\n   */\n  const updateScrollBottomVisibility = useCallback(() => {\n    const el = messagesRef.current\n    if (!el) return\n    const { scrollTop, scrollHeight, clientHeight } = el\n    const distanceFromBottom = scrollHeight - scrollTop - clientHeight\n    const shouldShow = distanceFromBottom > 50\n    if (showScrollToBottomRef.current !== shouldShow) {\n      showScrollToBottomRef.current = shouldShow\n      setShowScrollToBottom(shouldShow)\n    }\n  }, [])\n\n  /**\n   * Scroll inmediato al fondo (dentro de rAF para coordinar con el paint)\n   * y actualiza la visibilidad del botón. Respeta `skipIfUserScrolling` para\n   * no sobrescribir el scroll manual del usuario durante el streaming.\n   */\n  const scrollToBottomRaf = useCallback(\n    (opts: { skipIfUserScrolling?: boolean; delayMs?: number } = {}) => {\n      const { skipIfUserScrolling = false, delayMs = 0 } = opts\n      const run = () => {\n        requestAnimationFrame(() => {\n          const el = messagesRef.current\n          if (!el) return\n          if (skipIfUserScrolling && userScrollingRef.current) return\n          el.scrollTop = el.scrollHeight\n          updateScrollBottomVisibility()\n        })\n      }\n      if (delayMs > 0) setTimeout(run, delayMs)\n      else run()\n    },\n    [updateScrollBottomVisibility]\n  )\n\n  const handleClickScrollToBottom = useCallback(() => {\n    if (!messagesRef.current) return\n    messagesRef.current.scrollTo({\n      top: messagesRef.current.scrollHeight,\n      behavior: 'smooth',\n    })\n    // Dar tiempo al smooth-scroll antes de recalcular la visibilidad del botón.\n    setTimeout(updateScrollBottomVisibility, 500)\n  }, [updateScrollBottomVisibility])\n\n  // Al decidir en el ApprovalBox: el box colapsa (botones -> badge) y el stream\n  // continúa abajo. Reactivar el auto-scroll y seguir el fondo para que la vista\n  // no quede atrás (evita que aparezca la flecha de scroll-to-bottom).\n  const handleApprovalDecisionWithScroll = useCallback(\n    (...args: Parameters<typeof handleApprovalDecision>) => {\n      userScrollingRef.current = false\n      scrollThresholdRef.current = 39\n      handleApprovalDecision(...args)\n      scrollToBottomRaf()\n      scrollToBottomRaf({ delayMs: 100 })\n    },\n    [handleApprovalDecision, scrollToBottomRaf]\n  )\n\n  const handleScrollToBottom = useCallback(\n    (e: React.UIEvent<HTMLDivElement>) => {\n      const container = e.currentTarget\n\n      if (scrollRafRef.current !== null) {\n        cancelAnimationFrame(scrollRafRef.current)\n      }\n\n      scrollRafRef.current = requestAnimationFrame(() => {\n        scrollRafRef.current = null\n        const { scrollTop, scrollHeight, clientHeight } = container\n\n        const isScrollingUp = scrollTop < lastScrollTopRef.current\n\n        if (isScrollingUp) {\n          scrollThresholdRef.current = 15\n        }\n\n        const isNearBottom = scrollHeight - scrollTop - clientHeight < scrollThresholdRef.current\n\n        if (isNearBottom) {\n          scrollThresholdRef.current = 39\n        }\n\n        userScrollingRef.current = !isNearBottom\n        lastScrollTopRef.current = scrollTop\n\n        updateScrollBottomVisibility()\n\n        if (isNearBottom && onScrollToBottom) {\n          onScrollToBottom()\n        }\n\n        handleScroll(container)\n      })\n    },\n    [onScrollToBottom, handleScroll, updateScrollBottomVisibility]\n  )\n\n  // refs to stabilize functions and avoid unnecessary re-renders\n  const sendMessageRef = useRef(sendMessage)\n  const stopGenerationRef = useRef(stopGeneration)\n  const onSendMessageReadyRef = useRef(onSendMessageReady)\n  const sendMessageProxyRef = useRef(\n    (\n      message: string,\n      attachments?: AttachmentFile[],\n      faqId?: string,\n      agentSuggestionId?: string,\n      mentions?: ContextMention[],\n      fuaId?: string,\n      scId?: string\n    ) => sendMessageRef.current(message, attachments, faqId, agentSuggestionId, mentions, fuaId, scId)\n  )\n  const stopGenerationProxyRef = useRef(() => stopGenerationRef.current())\n\n  // update refs when functions change\n  sendMessageRef.current = sendMessage\n  stopGenerationRef.current = stopGeneration\n  onSendMessageReadyRef.current = onSendMessageReady\n\n  useEffect(() => {\n    if (onSendMessageReadyRef.current) {\n      onSendMessageReadyRef.current(\n        sendMessageProxyRef.current,\n        stopGenerationProxyRef.current,\n        waitingResponse,\n        isWriting\n      )\n    }\n  }, [waitingResponse, isWriting])\n\n  useEffect(() => {\n    isLoadingMoreRef.current = isLoadingMoreMessages\n  }, [isLoadingMoreMessages])\n\n  // Cuando el agente empieza a responder, resetear el flag y el umbral para activar el auto-scroll\n  useEffect(() => {\n    if (waitingResponse) {\n      userScrollingRef.current = false\n      scrollThresholdRef.current = 39\n    }\n  }, [waitingResponse])\n\n  useEffect(() => {\n    if (!chatInitializedRef.current) {\n      chatInitializedRef.current = true\n      initializeChat()\n    }\n  }, [])\n\n  // Autoscroll mientras el texto del stream crece. El texto se pinta al ritmo\n  // de `useSmoothStreamText` (~60fps), no al ritmo de llegada de tokens del\n  // backend: por eso acá usamos un loop de rAF que compara `scrollHeight`\n  // contra el último valor observado y ajusta solo cuando cambia. Así el\n  // scroll queda perfectamente sincronizado con la animación del texto sin\n  // depender de la cadencia del streamingStore.\n  useEffect(() => {\n    if (!waitingResponse && !isWriting) return undefined\n    if (!messagesRef.current) return undefined\n\n    let rafId: number | null = null\n    let lastHeight = messagesRef.current.scrollHeight\n\n    const tick = () => {\n      const el = messagesRef.current\n      if (!el) {\n        rafId = null\n        return\n      }\n      const currentHeight = el.scrollHeight\n      if (currentHeight !== lastHeight) {\n        lastHeight = currentHeight\n        if (!userScrollingRef.current) {\n          el.scrollTop = currentHeight\n        }\n        updateScrollBottomVisibility()\n      }\n      rafId = requestAnimationFrame(tick)\n    }\n\n    rafId = requestAnimationFrame(tick)\n    return () => {\n      if (rafId != null) cancelAnimationFrame(rafId)\n    }\n  }, [waitingResponse, isWriting, updateScrollBottomVisibility])\n\n  // Al comenzar a esperar la respuesta del backend, scroll inicial al fondo.\n  useEffect(() => {\n    if (waitingResponse && messagesRef.current) {\n      scrollToBottomRaf({ skipIfUserScrolling: true })\n    }\n  }, [waitingResponse, scrollToBottomRaf])\n\n  // Scroll cuando cambian los mensajes: distingue \"nuevo mensaje\" (agregado)\n  // de \"reemplazo\" (mismo id/length, ej. feedback o approvalStatus). En\n  // reemplazos solo se recalcula la visibilidad del botón sin forzar scroll.\n  const lastMessageIdRef = useRef<string | null>(null)\n  const lastMessagesLengthRef = useRef<number>(0)\n\n  // Al cambiar de sesión, resetear estado de scroll manual para no heredar el chat anterior.\n  useEffect(() => {\n    wasLoadingMessagesRef.current = false\n    lastScrolledSessionRef.current = null\n    userScrollingRef.current = false\n    scrollThresholdRef.current = 39\n    lastScrollTopRef.current = 0\n    lastMessageIdRef.current = null\n    lastMessagesLengthRef.current = 0\n  }, [initialChatId])\n\n  // Restauración desde cache (sin Loader): bajar al fondo al reabrir sesión visitada.\n  useLayoutEffect(() => {\n    if (loadingMessages || !initialChatId || messages.length === 0) return\n    if (lastScrolledSessionRef.current === initialChatId) return\n    lastScrolledSessionRef.current = initialChatId\n\n    userScrollingRef.current = false\n    scrollThresholdRef.current = 39\n    lastMessageIdRef.current = messages[messages.length - 1]?.id ?? null\n    lastMessagesLengthRef.current = messages.length\n\n    scrollToBottomRaf()\n    scrollToBottomRaf({ delayMs: 100 })\n  }, [initialChatId, loadingMessages, messages.length, messages, scrollToBottomRaf])\n\n  useEffect(() => {\n    if (!messagesRef.current || loadingMessages || isLoadingMoreMessages || isLoadingMoreRef.current) {\n      return\n    }\n\n    const lastMessage = messages[messages.length - 1]\n    const lastId = lastMessage?.id ?? null\n    const prevId = lastMessageIdRef.current\n    const prevLen = lastMessagesLengthRef.current\n    lastMessageIdRef.current = lastId\n    lastMessagesLengthRef.current = messages.length\n\n    const isNewMessage = lastId !== prevId || messages.length !== prevLen\n    if (!isNewMessage) {\n      updateScrollBottomVisibility()\n      return\n    }\n\n    const container = messagesRef.current\n    const isAtBottom = container.scrollHeight - container.scrollTop <= container.clientHeight + 100\n    const hasInitialMessage = messages.some(msg => msg.id === 'user-initial-message')\n    const isApproval = !!lastMessage && (lastMessage.id.startsWith('approval-') || !!lastMessage.approval)\n    const isAnswerOrQuestion =\n      !!lastMessage && (lastMessage.id.startsWith('answer-') || lastMessage.id.startsWith('question-'))\n\n    // Approval: secuencia de scrolls con delay porque el ApprovalBox necesita\n    // un tick para medirse. Scrollea aunque el usuario no esté al fondo si no\n    // está scrolleando manualmente.\n    if (isApproval && (isAtBottom || !userScrollingRef.current)) {\n      scrollToBottomRaf()\n      scrollToBottomRaf()\n      scrollToBottomRaf({ delayMs: 100 })\n      return\n    }\n\n    // Nuevos answer/question: scroll si el usuario ya estaba al fondo.\n    if (isAnswerOrQuestion && isAtBottom) {\n      scrollToBottomRaf()\n      return\n    }\n\n    // Caso borde: cambios de mensajes sin ser nuevo answer/user/approval\n    // pero sí un mensaje nuevo (no el \"user-initial-message\"). Scrollea.\n    if (!isAnswerOrQuestion && !isApproval && !hasInitialMessage && messages.length > prevLen) {\n      scrollToBottomRaf()\n      return\n    }\n\n    updateScrollBottomVisibility()\n  }, [messages, loadingMessages, isLoadingMoreMessages, scrollToBottomRaf, updateScrollBottomVisibility])\n\n  // Al abrir/cargar una conversación el contenedor se remonta (Loader → lista) con\n  // scrollTop=0. Forzamos ir al fondo al terminar loadMessages, sin afectar paginación hacia arriba.\n  useLayoutEffect(() => {\n    const justFinishedLoading = wasLoadingMessagesRef.current && !loadingMessages\n    wasLoadingMessagesRef.current = loadingMessages\n\n    if (!justFinishedLoading || messages.length === 0) return\n\n    userScrollingRef.current = false\n    scrollThresholdRef.current = 39\n    lastMessageIdRef.current = messages[messages.length - 1]?.id ?? null\n    lastMessagesLengthRef.current = messages.length\n\n    scrollToBottomRaf()\n    scrollToBottomRaf({ delayMs: 100 })\n  }, [loadingMessages, messages.length, scrollToBottomRaf])\n\n  // Obtener el último mensaje del usuario para verificar si tiene attachments\n  const lastUserMessage = messages\n    .filter(msg => msg.role === ChatHistoryRole.USER || msg.user.id === authUser.id.toString())\n    .at(-1)\n\n  const attachmentsCount =\n    (Array.isArray(lastUserMessage?.attachments) ? lastUserMessage.attachments.length : 0) ||\n    (Array.isArray(lastUserMessage?.sources) ? lastUserMessage.sources.length : 0)\n\n  const streamLoadingDisplay = resolveStreamLoadingDisplay({\n    streamActivity,\n    loadingMessage,\n    activeLoadings: activeLoadings || {},\n    waitingResponse,\n    isWebSearchActive,\n    isDeepSearchActive,\n    hasAttachments: Boolean(attachmentsCount),\n    attachmentsCount,\n    t,\n  })\n\n  const isScrollOnParent = !!expanded\n  const isMarketplaceGlobalAgent = isMaiakerAgent(agent)\n\n  // Al expandir/contraer el modal el ref pasa a otro contenedor (scrollTop se resetea a 0).\n  // Restaurar la posición de scroll antes del paint para evitar que la conversación salte arriba.\n  const expandedRef = useRef(expanded)\n  useLayoutEffect(() => {\n    if (expandedRef.current !== expanded && messagesRef.current) {\n      const savedScrollTop = lastScrollTopRef.current\n      messagesRef.current.scrollTop = savedScrollTop\n      expandedRef.current = expanded\n    } else {\n      expandedRef.current = expanded\n    }\n  }, [expanded])\n\n  if (loadingMessages) {\n    return (\n      <Fade fill>\n        <Loader />\n      </Fade>\n    )\n  }\n\n  const messagesContent = (\n    <>\n      {isLoadingMoreMessages && <LoadingText text={t('chat.loadingMore')} />}\n      <>\n        {messages.map((message, index) => {\n          const isAssistantMessage = message.role === ChatHistoryRole.ASSISTANT || message.user.id === 'assistant'\n          const isLastMessage = index === messages.length - 1\n          const isStreamingPlaceholder =\n            isAssistantMessage && isLastMessage && isStreamingPlaceholderMessageId(message.id)\n          const isStreaming = isStreamingPlaceholder && (waitingResponse || isWriting)\n\n          // No filtrar el placeholder del mensaje en streaming: su texto vive\n          // en el streamingStore y `message.message` es '' hasta el complete.\n          if (\n            !isStreamingPlaceholder &&\n            !isStreaming &&\n            !(message.attachments?.length || message.sources?.length) &&\n            !message.message &&\n            !message.project?.name &&\n            !message.approval\n          )\n            return null\n\n          const messageFeedback =\n            message?.wasHelpful === undefined || message.wasHelpful === null\n              ? null\n              : message.wasHelpful\n                ? Feedback.THUMBS_UP\n                : Feedback.THUMBS_DOWN\n\n          // Key estable: solo message.id para evitar remount durante streaming (message.date puede cambiar)\n          const messageKey = message.id ?? `msg-${index}`\n\n          const turnId = resolveRetryTurnId(message)\n          const userMessageForRetry = findUserMessageForRetry(messages, message)\n          const canRetry =\n            !!userMessageForRetry &&\n            !isStreaming &&\n            !message.isError &&\n            !message.approval &&\n            (message.isFrontendCancelled || (!message.is_cancelled && !!turnId))\n\n          return (\n            <MessageItem\n              {...message}\n              key={messageKey}\n              authUser={authUser}\n              handleSelectOption={handleSelectOption}\n              handleFeedback={handleFeedback}\n              handleApprovalDecision={handleApprovalDecisionWithScroll}\n              handleSuggestionClick={handleSuggestionClick}\n              handleRetry={canRetry ? () => retryMessage(message) : undefined}\n              hasSelectedSuggestion={!!selectedSuggestionMessageIds[message.id]}\n              disableFeedback={messageFeedback}\n              isStreaming={isStreaming}\n              isLastMessage={isLastMessage}\n              expanded={expanded}\n            />\n          )\n        })}\n      </>\n      {streamLoadingDisplay && (\n        <SCLoadingMessagesColumn>\n          <AgentActivityIndicator activity={streamLoadingDisplay} />\n        </SCLoadingMessagesColumn>\n      )}\n    </>\n  )\n\n  return (\n    <SCMessagesOuter $scrollOnParent={isScrollOnParent}>\n      {isScrollOnParent ? (\n        <SCMessagesScroll ref={messagesRef} onScroll={handleScrollToBottom}>\n          <SCMessagesInner $scrollOnParent={isScrollOnParent} $isMarketplaceGlobal={isMarketplaceGlobalAgent}>\n            {messagesContent}\n          </SCMessagesInner>\n        </SCMessagesScroll>\n      ) : (\n        <SCMessagesInner\n          ref={messagesRef}\n          onScroll={handleScrollToBottom}\n          $scrollOnParent={false}\n          $isMarketplaceGlobal={isMarketplaceGlobalAgent}\n        >\n          {messagesContent}\n        </SCMessagesInner>\n      )}\n\n      {showScrollToBottom && (\n        <ScrollToBottomButton type=\"button\" onClick={handleClickScrollToBottom}>\n          <ArrowSmallDown color=\"#666\" width=\"20px\" height=\"20px\" />\n        </ScrollToBottomButton>\n      )}\n    </SCMessagesOuter>\n  )\n}\n\nexport const ChatAIMessages = React.memo(ChatAIMessagesInner)\n"],"mappings":"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","ignoreList":[]}