@projectcor/maia-components 2.38.1 → 2.38.2

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

@@ -0,0 +1,291 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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; }
+import { renderWithProviders, screen } from '../../../test/test-utils';
+import { GlobalContextTestProvider } from '../../../test/global-context';
+import { ChatHistoryRole } from '../../../types/Chat';
+import { ChatAIMessages } from './ChatAIMessages';
+import { jsx as _jsx } from "react/jsx-runtime";
+var sendMessage = jest.fn();
+var stopGeneration = jest.fn();
+var initializeChat = jest.fn();
+var chatManager = {
+  messages: [],
+  loadingMessages: false,
+  isLoadingMoreMessages: false,
+  waitingResponse: false,
+  isWriting: false,
+  loadingMessage: null,
+  streamActivity: null,
+  activeLoadings: {},
+  sendMessage: sendMessage,
+  retryMessage: jest.fn(),
+  changeProject: jest.fn(),
+  handleFeedback: jest.fn(),
+  handleApprovalDecision: jest.fn(),
+  initializeChat: initializeChat,
+  handleScroll: jest.fn(),
+  stopGeneration: stopGeneration
+};
+jest.mock('../../../hooks/useChatManager/useChatManager', function () {
+  return {
+    useChatManager: function useChatManager() {
+      return chatManager;
+    }
+  };
+});
+jest.mock('../../../hooks/useStreamingMessage', function () {
+  return {
+    useStreamingMessage: function useStreamingMessage() {
+      return '';
+    }
+  };
+});
+jest.mock('../../../hooks/useSmoothStreamText', function () {
+  return {
+    useSmoothStreamText: function useSmoothStreamText(text) {
+      return text;
+    }
+  };
+});
+jest.mock('../../../hooks/useReasoningTrace', function () {
+  return {
+    useReasoningTrace: function useReasoningTrace() {
+      return {
+        steps: [],
+        summary: null
+      };
+    }
+  };
+});
+jest.mock('../../../hooks/useEvent', function () {
+  return {
+    EVENTS: {
+      aiChatSuggestedAnswer: 'AI_CHAT_SUGGESTED_ANSWER'
+    },
+    useEvent: function useEvent() {
+      return jest.fn();
+    }
+  };
+});
+jest.mock('../../../context/cor-user', function () {
+  return {
+    CORUserRole: {
+      CLIENT: 6,
+      FREELANCER: 5
+    },
+    useUser: function useUser() {
+      return {
+        id: 99,
+        company_id: 10
+      };
+    }
+  };
+});
+jest.mock('../../../store/maiaPanelSessionPersistence', function () {
+  return {
+    patchMaiaPanelSession: jest.fn(),
+    readMaiaPanelSession: jest.fn(function () {
+      return null;
+    })
+  };
+});
+jest.mock('../../atoms/MaiaStreamdown', function () {
+  return {
+    MaiaStreamdown: function MaiaStreamdown(_ref) {
+      var children = _ref.children;
+      return /*#__PURE__*/_jsx("div", {
+        children: children
+      });
+    }
+  };
+});
+jest.mock('../../atoms/MaiaStreamdown/MaiaStreamdown', function () {
+  return {
+    MaiaStreamdown: function MaiaStreamdown(_ref2) {
+      var children = _ref2.children;
+      return /*#__PURE__*/_jsx("div", {
+        children: children
+      });
+    }
+  };
+});
+jest.mock('../../atoms/ReasoningBlock/ReasoningBlock', function () {
+  return {
+    ReasoningBlock: function ReasoningBlock() {
+      return null;
+    }
+  };
+});
+jest.mock('../../atoms/ReasoningBlock/ReasoningTimeline', function () {
+  return {
+    ReasoningTimeline: function ReasoningTimeline() {
+      return null;
+    }
+  };
+});
+jest.mock('../../atoms/ReasoningBlock/reasoningLiveNarration', function () {
+  return {
+    shouldStreamNarrationInTimeline: function shouldStreamNarrationInTimeline() {
+      return false;
+    }
+  };
+});
+jest.mock('../../atoms/AgentActivityIndicator', function () {
+  return {
+    AgentActivityIndicator: function AgentActivityIndicator() {
+      return null;
+    }
+  };
+});
+jest.mock('../../atoms/LoadingText', function () {
+  return {
+    LoadingText: function LoadingText() {
+      return null;
+    }
+  };
+});
+jest.mock('./ChatAICreateAgentActions', function () {
+  return {
+    ChatAICreateAgentActions: function ChatAICreateAgentActions() {
+      return null;
+    }
+  };
+});
+jest.mock('../MessageFeedback', function () {
+  return {
+    MessageFeedback: function MessageFeedback() {
+      return null;
+    }
+  };
+});
+jest.mock('../../atoms/Loader', function () {
+  return {
+    Loader: function Loader() {
+      return /*#__PURE__*/_jsx("div", {
+        role: "status",
+        children: "loading"
+      });
+    }
+  };
+});
+jest.mock('../ChatFooter/ChatFooter', function () {
+  return {};
+});
+jest.mock('../../atoms/AttachmentCard/AttachmentCard', function () {
+  return {
+    AttachmentCard: function AttachmentCard() {
+      return null;
+    }
+  };
+});
+jest.mock('../../atoms/AttachmentCard/AttachmentCardAudio', function () {
+  return {
+    AttachmentCardAudio: function AttachmentCardAudio() {
+      return null;
+    }
+  };
+});
+jest.mock('../../atoms/ApprovalBox/ApprovalBox', function () {
+  return {
+    ApprovalBox: function ApprovalBox() {
+      return null;
+    }
+  };
+});
+jest.mock('../../atoms/AttachmentPreviewModal', function () {
+  return {
+    AttachmentPreviewModal: function AttachmentPreviewModal() {
+      return null;
+    }
+  };
+});
+var defaultProps = {
+  userInitialMessage: {
+    message: '',
+    attachments: []
+  },
+  initialChatId: null,
+  onError: jest.fn()
+};
+var userMessage = function userMessage(text) {
+  return {
+    id: 'u1',
+    message: text,
+    date: new Date('2026-01-02T10:00:00.000Z'),
+    user: {
+      id: '99',
+      name: 'Luis'
+    },
+    role: ChatHistoryRole.USER
+  };
+};
+var assistantMessage = function assistantMessage(text) {
+  return {
+    id: 'a1',
+    message: text,
+    date: new Date('2026-01-02T10:00:01.000Z'),
+    user: {
+      id: 'assistant',
+      name: 'MAIA'
+    },
+    role: ChatHistoryRole.ASSISTANT
+  };
+};
+describe('ChatAIMessages', function () {
+  beforeEach(function () {
+    chatManager.messages = [];
+    chatManager.loadingMessages = false;
+    chatManager.waitingResponse = false;
+    chatManager.isWriting = false;
+    jest.clearAllMocks();
+  });
+  it('shows a loader while messages are loading', function () {
+    chatManager.loadingMessages = true;
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(ChatAIMessages, _objectSpread({}, defaultProps))
+    }));
+    expect(screen.getByRole('status')).toHaveTextContent('loading');
+    expect(initializeChat).toHaveBeenCalled();
+  });
+  it('renders an empty conversation without crashing', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+        children: /*#__PURE__*/_jsx(ChatAIMessages, _objectSpread({}, defaultProps))
+      })),
+      container = _renderWithProviders.container;
+    expect(screen.queryByRole('status')).not.toBeInTheDocument();
+    expect(container).toHaveTextContent('');
+  });
+  it('renders user and assistant messages', function () {
+    chatManager.messages = [userMessage('Hola MAIA'), assistantMessage('Hola, ¿en qué te ayudo?')];
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(ChatAIMessages, _objectSpread(_objectSpread({}, defaultProps), {}, {
+        initialChatId: "s1"
+      }))
+    }));
+    expect(screen.getByText('Hola MAIA')).toBeInTheDocument();
+    expect(screen.getByText('Hola, ¿en qué te ayudo?')).toBeInTheDocument();
+  });
+  it('exposes send and stop through onSendMessageReady', function () {
+    var onSendMessageReady = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(GlobalContextTestProvider, {
+      children: /*#__PURE__*/_jsx(ChatAIMessages, _objectSpread(_objectSpread({}, defaultProps), {}, {
+        onSendMessageReady: onSendMessageReady
+      }))
+    }));
+    expect(onSendMessageReady).toHaveBeenCalled();
+    var _onSendMessageReady$m = _slicedToArray(onSendMessageReady.mock.calls[0], 4),
+      send = _onSendMessageReady$m[0],
+      stop = _onSendMessageReady$m[1],
+      isStreaming = _onSendMessageReady$m[2],
+      isWriting = _onSendMessageReady$m[3];
+    send('Resumí el brief');
+    stop();
+    expect(sendMessage).toHaveBeenCalledWith('Resumí el brief', undefined, undefined, undefined, undefined, undefined, undefined);
+    expect(stopGeneration).toHaveBeenCalled();
+    expect(isStreaming).toBe(false);
+    expect(isWriting).toBe(false);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["renderWithProviders","screen","GlobalContextTestProvider","ChatHistoryRole","ChatAIMessages","jsx","_jsx","sendMessage","jest","fn","stopGeneration","initializeChat","chatManager","messages","loadingMessages","isLoadingMoreMessages","waitingResponse","isWriting","loadingMessage","streamActivity","activeLoadings","retryMessage","changeProject","handleFeedback","handleApprovalDecision","handleScroll","mock","useChatManager","useStreamingMessage","useSmoothStreamText","text","useReasoningTrace","steps","summary","EVENTS","aiChatSuggestedAnswer","useEvent","CORUserRole","CLIENT","FREELANCER","useUser","id","company_id","patchMaiaPanelSession","readMaiaPanelSession","MaiaStreamdown","_ref","children","_ref2","ReasoningBlock","ReasoningTimeline","shouldStreamNarrationInTimeline","AgentActivityIndicator","LoadingText","ChatAICreateAgentActions","MessageFeedback","Loader","role","AttachmentCard","AttachmentCardAudio","ApprovalBox","AttachmentPreviewModal","defaultProps","userInitialMessage","message","attachments","initialChatId","onError","userMessage","date","Date","user","name","USER","assistantMessage","ASSISTANT","describe","beforeEach","clearAllMocks","it","_objectSpread","expect","getByRole","toHaveTextContent","toHaveBeenCalled","_renderWithProviders","container","queryByRole","not","toBeInTheDocument","getByText","onSendMessageReady","_onSendMessageReady$m","_slicedToArray","calls","send","stop","isStreaming","toHaveBeenCalledWith","undefined","toBe"],"sources":["../../../../src/components/molecules/ChatAIMessages/ChatAIMessages.spec.tsx"],"sourcesContent":["import { renderWithProviders, screen } from '../../../test/test-utils'\nimport { GlobalContextTestProvider } from '../../../test/global-context'\nimport { ChatHistoryRole } from '../../../types/Chat'\nimport type { ChatMessage } from '../../../types/Chat'\nimport { ChatAIMessages } from './ChatAIMessages'\n\nconst sendMessage = jest.fn()\nconst stopGeneration = jest.fn()\nconst initializeChat = jest.fn()\n\nconst chatManager = {\n  messages: [] as ChatMessage[],\n  loadingMessages: false,\n  isLoadingMoreMessages: false,\n  waitingResponse: false,\n  isWriting: false,\n  loadingMessage: null,\n  streamActivity: null,\n  activeLoadings: {},\n  sendMessage,\n  retryMessage: jest.fn(),\n  changeProject: jest.fn(),\n  handleFeedback: jest.fn(),\n  handleApprovalDecision: jest.fn(),\n  initializeChat,\n  handleScroll: jest.fn(),\n  stopGeneration,\n}\n\njest.mock('../../../hooks/useChatManager/useChatManager', () => ({\n  useChatManager: () => chatManager,\n}))\n\njest.mock('../../../hooks/useStreamingMessage', () => ({\n  useStreamingMessage: () => '',\n}))\n\njest.mock('../../../hooks/useSmoothStreamText', () => ({\n  useSmoothStreamText: (text: string) => text,\n}))\n\njest.mock('../../../hooks/useReasoningTrace', () => ({\n  useReasoningTrace: () => ({ steps: [], summary: null }),\n}))\n\njest.mock('../../../hooks/useEvent', () => ({\n  EVENTS: { aiChatSuggestedAnswer: 'AI_CHAT_SUGGESTED_ANSWER' },\n  useEvent: () => jest.fn(),\n}))\n\njest.mock('../../../context/cor-user', () => ({\n  CORUserRole: { CLIENT: 6, FREELANCER: 5 },\n  useUser: () => ({ id: 99, company_id: 10 }),\n}))\n\njest.mock('../../../store/maiaPanelSessionPersistence', () => ({\n  patchMaiaPanelSession: jest.fn(),\n  readMaiaPanelSession: jest.fn(() => null),\n}))\n\njest.mock('../../atoms/MaiaStreamdown', () => ({\n  MaiaStreamdown: ({ children }: { children: string }) => <div>{children}</div>,\n}))\n\njest.mock('../../atoms/MaiaStreamdown/MaiaStreamdown', () => ({\n  MaiaStreamdown: ({ children }: { children: string }) => <div>{children}</div>,\n}))\n\njest.mock('../../atoms/ReasoningBlock/ReasoningBlock', () => ({\n  ReasoningBlock: () => null,\n}))\n\njest.mock('../../atoms/ReasoningBlock/ReasoningTimeline', () => ({\n  ReasoningTimeline: () => null,\n}))\n\njest.mock('../../atoms/ReasoningBlock/reasoningLiveNarration', () => ({\n  shouldStreamNarrationInTimeline: () => false,\n}))\n\njest.mock('../../atoms/AgentActivityIndicator', () => ({\n  AgentActivityIndicator: () => null,\n}))\n\njest.mock('../../atoms/LoadingText', () => ({\n  LoadingText: () => null,\n}))\n\njest.mock('./ChatAICreateAgentActions', () => ({\n  ChatAICreateAgentActions: () => null,\n}))\n\njest.mock('../MessageFeedback', () => ({\n  MessageFeedback: () => null,\n}))\n\njest.mock('../../atoms/Loader', () => ({\n  Loader: () => <div role=\"status\">loading</div>,\n}))\n\njest.mock('../ChatFooter/ChatFooter', () => ({}))\n\njest.mock('../../atoms/AttachmentCard/AttachmentCard', () => ({\n  AttachmentCard: () => null,\n}))\n\njest.mock('../../atoms/AttachmentCard/AttachmentCardAudio', () => ({\n  AttachmentCardAudio: () => null,\n}))\n\njest.mock('../../atoms/ApprovalBox/ApprovalBox', () => ({\n  ApprovalBox: () => null,\n}))\n\njest.mock('../../atoms/AttachmentPreviewModal', () => ({\n  AttachmentPreviewModal: () => null,\n}))\n\nconst defaultProps = {\n  userInitialMessage: { message: '', attachments: [] },\n  initialChatId: null as string | null,\n  onError: jest.fn(),\n}\n\nconst userMessage = (text: string): ChatMessage => ({\n  id: 'u1',\n  message: text,\n  date: new Date('2026-01-02T10:00:00.000Z'),\n  user: { id: '99', name: 'Luis' },\n  role: ChatHistoryRole.USER,\n})\n\nconst assistantMessage = (text: string): ChatMessage => ({\n  id: 'a1',\n  message: text,\n  date: new Date('2026-01-02T10:00:01.000Z'),\n  user: { id: 'assistant', name: 'MAIA' },\n  role: ChatHistoryRole.ASSISTANT,\n})\n\ndescribe('ChatAIMessages', () => {\n  beforeEach(() => {\n    chatManager.messages = []\n    chatManager.loadingMessages = false\n    chatManager.waitingResponse = false\n    chatManager.isWriting = false\n    jest.clearAllMocks()\n  })\n\n  it('shows a loader while messages are loading', () => {\n    chatManager.loadingMessages = true\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <ChatAIMessages {...defaultProps} />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByRole('status')).toHaveTextContent('loading')\n    expect(initializeChat).toHaveBeenCalled()\n  })\n\n  it('renders an empty conversation without crashing', () => {\n    const { container } = renderWithProviders(\n      <GlobalContextTestProvider>\n        <ChatAIMessages {...defaultProps} />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.queryByRole('status')).not.toBeInTheDocument()\n    expect(container).toHaveTextContent('')\n  })\n\n  it('renders user and assistant messages', () => {\n    chatManager.messages = [userMessage('Hola MAIA'), assistantMessage('Hola, ¿en qué te ayudo?')]\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <ChatAIMessages {...defaultProps} initialChatId=\"s1\" />\n      </GlobalContextTestProvider>\n    )\n\n    expect(screen.getByText('Hola MAIA')).toBeInTheDocument()\n    expect(screen.getByText('Hola, ¿en qué te ayudo?')).toBeInTheDocument()\n  })\n\n  it('exposes send and stop through onSendMessageReady', () => {\n    const onSendMessageReady = jest.fn()\n    renderWithProviders(\n      <GlobalContextTestProvider>\n        <ChatAIMessages {...defaultProps} onSendMessageReady={onSendMessageReady} />\n      </GlobalContextTestProvider>\n    )\n\n    expect(onSendMessageReady).toHaveBeenCalled()\n    const [send, stop, isStreaming, isWriting] = onSendMessageReady.mock.calls[0]\n    send('Resumí el brief')\n    stop()\n\n    expect(sendMessage).toHaveBeenCalledWith(\n      'Resumí el brief',\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined\n    )\n    expect(stopGeneration).toHaveBeenCalled()\n    expect(isStreaming).toBe(false)\n    expect(isWriting).toBe(false)\n  })\n})\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,46 @@
+import { fireEvent, renderWithProviders, screen } from '../../../test/test-utils';
+import { ChatAISuggestions } from './ChatAISuggestions';
+import { jsx as _jsx } from "react/jsx-runtime";
+describe('ChatAISuggestions', function () {
+  it('returns null without suggestions', function () {
+    var _renderWithProviders = renderWithProviders(/*#__PURE__*/_jsx(ChatAISuggestions, {
+        suggestions: [],
+        onSelectSuggestion: jest.fn()
+      })),
+      container = _renderWithProviders.container;
+    expect(container).toBeEmptyDOMElement();
+  });
+  it('selects a suggestion and refocuses the input', function () {
+    jest.spyOn(window, 'requestAnimationFrame').mockImplementation(function (cb) {
+      cb(0);
+      return 0;
+    });
+    var onSelectSuggestion = jest.fn();
+    var onRefocus = jest.fn();
+    document.addEventListener('maia-input-refocus', onRefocus);
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAISuggestions, {
+      suggestions: ['Resumí el brief', 'Creá una tarea'],
+      onSelectSuggestion: onSelectSuggestion
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: /Resumí el brief/
+    }));
+    expect(onSelectSuggestion).toHaveBeenCalledWith('Resumí el brief');
+    expect(onRefocus).toHaveBeenCalled();
+    document.removeEventListener('maia-input-refocus', onRefocus);
+    window.requestAnimationFrame.mockRestore();
+  });
+  it('does not select when disabled', function () {
+    var onSelectSuggestion = jest.fn();
+    renderWithProviders(/*#__PURE__*/_jsx(ChatAISuggestions, {
+      suggestions: ['Resumí'],
+      onSelectSuggestion: onSelectSuggestion,
+      disabled: true
+    }));
+    fireEvent.click(screen.getByRole('button', {
+      name: /Resumí/
+    }));
+    expect(onSelectSuggestion).not.toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/components/molecules/ChatAIModal/ChatAIModal.styles.js

@@ -43,7 +43,7 @@ export var SCCAIMContent = styled.div.withConfig({
   if (floating) {
     return css(["width:", "px;@media (min-width:", "px){width:", "px;}@media (min-width:", "px){width:", "px;}"], MAIA_FLOATING_PANEL_WIDTH_PX["default"], MAIA_FLOATING_BREAKPOINT_LARGE, MAIA_FLOATING_PANEL_WIDTH_PX.large, MAIA_FLOATING_BREAKPOINT_XXL, MAIA_FLOATING_PANEL_WIDTH_PX.xxl);
   }
-  return css(["width:490px;"]);
+  return css(["width:480px;"]);
 }, function (_ref8) {
   var floating = _ref8.floating;
   return floating && css(["border-radius:8px;border-top-left-radius:8px;border-bottom-left-radius:8px;"]);
@@ -55,4 +55,4 @@ export var SCCAIMMinimizedHide = styled.div.withConfig({
   var $hidden = _ref9.$hidden;
   return $hidden ? 'none' : 'contents';
 });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["styled","css","MAIA_FLOATING_BREAKPOINT_LARGE","MAIA_FLOATING_BREAKPOINT_XXL","MAIA_FLOATING_PANEL_HEIGHT_PX","MAIA_FLOATING_PANEL_WIDTH_PX","MAIA_TASK_PANEL_CHAT_MODAL_Z_INDEX","SCCAIMWrapper","div","withConfig","displayName","componentId","_ref","$minimized","_ref2","elevated","_ref3","expanded","_ref4","layoutMode","dragPosition","y","x","SCCAIMContentWrapper","_ref5","width","_ref6","floating","large","xxl","SCCAIMContent","_ref7","_ref8","SCCAIMMinimizedHide","_ref9","$hidden"],"sources":["../../../../src/components/molecules/ChatAIModal/ChatAIModal.styles.tsx"],"sourcesContent":["import styled, { css } from 'styled-components'\nimport type { MaiaChatModalLayoutMode } from './layout'\nimport {\n  MAIA_FLOATING_BREAKPOINT_LARGE,\n  MAIA_FLOATING_BREAKPOINT_XXL,\n  MAIA_FLOATING_PANEL_HEIGHT_PX,\n  MAIA_FLOATING_PANEL_WIDTH_PX,\n} from './layout'\nimport { MAIA_TASK_PANEL_CHAT_MODAL_Z_INDEX } from '../../../constants/maiaTaskPanelZIndex'\n\nexport const SCCAIMWrapper = styled.div<{\n  expanded: boolean\n  layoutMode: MaiaChatModalLayoutMode\n  dragPosition?: { x: number; y: number } | null\n  elevated?: boolean\n  $minimized?: boolean\n}>`\n  box-sizing: border-box;\n  ${({ $minimized }) =>\n    $minimized &&\n    css`\n      pointer-events: none;\n    `}\n  /* z-index alto cuando se abre desde el task panel (z-index 9800000); el default\n     cubre los flujos restantes de Maia. */\n  z-index: ${({ elevated }) => (elevated ? MAIA_TASK_PANEL_CHAT_MODAL_Z_INDEX : 1099)};\n  height: 100vh;\n  display: flex;\n  justify-content: flex-end;\n  align-items: center;\n  position: fixed;\n  padding: 16px;\n  top: 0;\n  right: 0;\n  transition: width 0.1s ease-out-in;\n  ${({ expanded }) =>\n    expanded &&\n    css`\n      left: 0;\n      right: 0;\n      width: 100%;\n      max-width: 100vw;\n    `}\n  ${({ layoutMode, dragPosition, expanded }) =>\n    layoutMode === 'floating' &&\n    dragPosition &&\n    !expanded &&\n    css`\n      top: ${dragPosition.y}px;\n      left: ${dragPosition.x}px;\n      right: auto;\n      padding: 0;\n      width: auto;\n      height: auto;\n      max-height: none;\n      align-items: flex-start;\n      justify-content: flex-start;\n      transition: none;\n    `}\n`\n\nexport const SCCAIMContentWrapper = styled.div<{\n  expanded: boolean\n  floating?: boolean\n}>`\n  position: relative;\n  height: 100%;\n  display: flex;\n  border-radius: 8px;\n  box-shadow: 0px 4px 16px rgba(18, 18, 18, 0.24);\n  font-family: Work Sans;\n  transition: width 0.1s ease-out-in;\n  overflow: hidden;\n  ${({ expanded }) => (expanded ? { width: '100%' } : {})}\n  ${({ floating }) =>\n    floating &&\n    css`\n      height: ${MAIA_FLOATING_PANEL_HEIGHT_PX.default}px;\n      max-height: 85vh;\n      @media (min-width: ${MAIA_FLOATING_BREAKPOINT_LARGE}px) {\n        height: ${MAIA_FLOATING_PANEL_HEIGHT_PX.large}px;\n      }\n      @media (min-width: ${MAIA_FLOATING_BREAKPOINT_XXL}px) {\n        height: ${MAIA_FLOATING_PANEL_HEIGHT_PX.xxl}px;\n      }\n    `}\n`\n\nexport const SCCAIMContent = styled.div<{\n  expanded: boolean\n  floating?: boolean\n}>`\n  background: white;\n  border-radius: inherit;\n  border-top-left-radius: 0;\n  border-bottom-left-radius: 0;\n  display: flex;\n  flex-direction: column;\n  height: 100%;\n  overflow: hidden;\n  overscroll-behavior: contain;\n  transition: all 0.3s ease-out-in;\n  ${({ expanded, floating }) => {\n    if (expanded) {\n      return css`\n        flex: 1;\n      `\n    }\n    if (floating) {\n      return css`\n        width: ${MAIA_FLOATING_PANEL_WIDTH_PX.default}px;\n        @media (min-width: ${MAIA_FLOATING_BREAKPOINT_LARGE}px) {\n          width: ${MAIA_FLOATING_PANEL_WIDTH_PX.large}px;\n        }\n        @media (min-width: ${MAIA_FLOATING_BREAKPOINT_XXL}px) {\n          width: ${MAIA_FLOATING_PANEL_WIDTH_PX.xxl}px;\n        }\n      `\n    }\n    return css`\n      width: 490px;\n    `\n  }}\n  ${({ floating }) =>\n    floating &&\n    css`\n      border-radius: 8px;\n      border-top-left-radius: 8px;\n      border-bottom-left-radius: 8px;\n    `}\n`\n\nexport const SCCAIMMinimizedHide = styled.div<{ $hidden: boolean }>`\n  display: ${({ $hidden }) => ($hidden ? 'none' : 'contents')};\n`\n"],"mappings":"AAAA,OAAOA,MAAM,IAAIC,GAAG,QAAQ,mBAAmB;AAE/C,SACEC,8BAA8B,EAC9BC,4BAA4B,EAC5BC,6BAA6B,EAC7BC,4BAA4B,QACvB,UAAU;AACjB,SAASC,kCAAkC,QAAQ,wCAAwC;AAE3F,OAAO,IAAMC,aAAa,GAAGP,MAAM,CAACQ,GAAG,CAAAC,UAAA;EAAAC,WAAA;EAAAC,WAAA;AAAA,4MAQnC,UAAAC,IAAA;EAAA,IAAGC,UAAU,GAAAD,IAAA,CAAVC,UAAU;EAAA,OACbA,UAAU,IACVZ,GAAG,0BAEF;AAAA,GAGQ,UAAAa,KAAA;EAAA,IAAGC,QAAQ,GAAAD,KAAA,CAARC,QAAQ;EAAA,OAAQA,QAAQ,GAAGT,kCAAkC,GAAG,IAAI;AAAA,CAAC,EAUjF,UAAAU,KAAA;EAAA,IAAGC,QAAQ,GAAAD,KAAA,CAARC,QAAQ;EAAA,OACXA,QAAQ,IACRhB,GAAG,gDAKF;AAAA,GACD,UAAAiB,KAAA;EAAA,IAAGC,UAAU,GAAAD,KAAA,CAAVC,UAAU;IAAEC,YAAY,GAAAF,KAAA,CAAZE,YAAY;IAAEH,QAAQ,GAAAC,KAAA,CAARD,QAAQ;EAAA,OACrCE,UAAU,KAAK,UAAU,IACzBC,YAAY,IACZ,CAACH,QAAQ,IACThB,GAAG,4JACMmB,YAAY,CAACC,CAAC,EACbD,YAAY,CAACE,CAAC,CASvB;AAAA,EACJ;AAED,OAAO,IAAMC,oBAAoB,GAAGvB,MAAM,CAACQ,GAAG,CAAAC,UAAA;EAAAC,WAAA;EAAAC,WAAA;AAAA,mMAY1C,UAAAa,KAAA;EAAA,IAAGP,QAAQ,GAAAO,KAAA,CAARP,QAAQ;EAAA,OAAQA,QAAQ,GAAG;IAAEQ,KAAK,EAAE;EAAO,CAAC,GAAG,CAAC,CAAC;AAAA,CAAC,EACrD,UAAAC,KAAA;EAAA,IAAGC,QAAQ,GAAAD,KAAA,CAARC,QAAQ;EAAA,OACXA,QAAQ,IACR1B,GAAG,uHACSG,6BAA6B,WAAQ,EAE1BF,8BAA8B,EACvCE,6BAA6B,CAACwB,KAAK,EAE1BzB,4BAA4B,EACrCC,6BAA6B,CAACyB,GAAG,CAE9C;AAAA,EACJ;AAED,OAAO,IAAMC,aAAa,GAAG9B,MAAM,CAACQ,GAAG,CAAAC,UAAA;EAAAC,WAAA;EAAAC,WAAA;AAAA,yOAcnC,UAAAoB,KAAA,EAA4B;EAAA,IAAzBd,QAAQ,GAAAc,KAAA,CAARd,QAAQ;IAAEU,QAAQ,GAAAI,KAAA,CAARJ,QAAQ;EACrB,IAAIV,QAAQ,EAAE;IACZ,OAAOhB,GAAG;EAGZ;EACA,IAAI0B,QAAQ,EAAE;IACZ,OAAO1B,GAAG,oGACCI,4BAA4B,WAAQ,EACxBH,8BAA8B,EACxCG,4BAA4B,CAACuB,KAAK,EAExBzB,4BAA4B,EACtCE,4BAA4B,CAACwB,GAAG;EAG/C;EACA,OAAO5B,GAAG;AAGZ,CAAC,EACC,UAAA+B,KAAA;EAAA,IAAGL,QAAQ,GAAAK,KAAA,CAARL,QAAQ;EAAA,OACXA,QAAQ,IACR1B,GAAG,iFAIF;AAAA,EACJ;AAED,OAAO,IAAMgC,mBAAmB,GAAGjC,MAAM,CAACQ,GAAG,CAAAC,UAAA;EAAAC,WAAA;EAAAC,WAAA;AAAA,sBAChC,UAAAuB,KAAA;EAAA,IAAGC,OAAO,GAAAD,KAAA,CAAPC,OAAO;EAAA,OAAQA,OAAO,GAAG,MAAM,GAAG,UAAU;AAAA,CAAC,CAC5D","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["styled","css","MAIA_FLOATING_BREAKPOINT_LARGE","MAIA_FLOATING_BREAKPOINT_XXL","MAIA_FLOATING_PANEL_HEIGHT_PX","MAIA_FLOATING_PANEL_WIDTH_PX","MAIA_TASK_PANEL_CHAT_MODAL_Z_INDEX","SCCAIMWrapper","div","withConfig","displayName","componentId","_ref","$minimized","_ref2","elevated","_ref3","expanded","_ref4","layoutMode","dragPosition","y","x","SCCAIMContentWrapper","_ref5","width","_ref6","floating","large","xxl","SCCAIMContent","_ref7","_ref8","SCCAIMMinimizedHide","_ref9","$hidden"],"sources":["../../../../src/components/molecules/ChatAIModal/ChatAIModal.styles.tsx"],"sourcesContent":["import styled, { css } from 'styled-components'\nimport type { MaiaChatModalLayoutMode } from './layout'\nimport {\n  MAIA_FLOATING_BREAKPOINT_LARGE,\n  MAIA_FLOATING_BREAKPOINT_XXL,\n  MAIA_FLOATING_PANEL_HEIGHT_PX,\n  MAIA_FLOATING_PANEL_WIDTH_PX,\n} from './layout'\nimport { MAIA_TASK_PANEL_CHAT_MODAL_Z_INDEX } from '../../../constants/maiaTaskPanelZIndex'\n\nexport const SCCAIMWrapper = styled.div<{\n  expanded: boolean\n  layoutMode: MaiaChatModalLayoutMode\n  dragPosition?: { x: number; y: number } | null\n  elevated?: boolean\n  $minimized?: boolean\n}>`\n  box-sizing: border-box;\n  ${({ $minimized }) =>\n    $minimized &&\n    css`\n      pointer-events: none;\n    `}\n  /* z-index alto cuando se abre desde el task panel (z-index 9800000); el default\n     cubre los flujos restantes de Maia. */\n  z-index: ${({ elevated }) => (elevated ? MAIA_TASK_PANEL_CHAT_MODAL_Z_INDEX : 1099)};\n  height: 100vh;\n  display: flex;\n  justify-content: flex-end;\n  align-items: center;\n  position: fixed;\n  padding: 16px;\n  top: 0;\n  right: 0;\n  transition: width 0.1s ease-out-in;\n  ${({ expanded }) =>\n    expanded &&\n    css`\n      left: 0;\n      right: 0;\n      width: 100%;\n      max-width: 100vw;\n    `}\n  ${({ layoutMode, dragPosition, expanded }) =>\n    layoutMode === 'floating' &&\n    dragPosition &&\n    !expanded &&\n    css`\n      top: ${dragPosition.y}px;\n      left: ${dragPosition.x}px;\n      right: auto;\n      padding: 0;\n      width: auto;\n      height: auto;\n      max-height: none;\n      align-items: flex-start;\n      justify-content: flex-start;\n      transition: none;\n    `}\n`\n\nexport const SCCAIMContentWrapper = styled.div<{\n  expanded: boolean\n  floating?: boolean\n}>`\n  position: relative;\n  height: 100%;\n  display: flex;\n  border-radius: 8px;\n  box-shadow: 0px 4px 16px rgba(18, 18, 18, 0.24);\n  font-family: Work Sans;\n  transition: width 0.1s ease-out-in;\n  overflow: hidden;\n  ${({ expanded }) => (expanded ? { width: '100%' } : {})}\n  ${({ floating }) =>\n    floating &&\n    css`\n      height: ${MAIA_FLOATING_PANEL_HEIGHT_PX.default}px;\n      max-height: 85vh;\n      @media (min-width: ${MAIA_FLOATING_BREAKPOINT_LARGE}px) {\n        height: ${MAIA_FLOATING_PANEL_HEIGHT_PX.large}px;\n      }\n      @media (min-width: ${MAIA_FLOATING_BREAKPOINT_XXL}px) {\n        height: ${MAIA_FLOATING_PANEL_HEIGHT_PX.xxl}px;\n      }\n    `}\n`\n\nexport const SCCAIMContent = styled.div<{\n  expanded: boolean\n  floating?: boolean\n}>`\n  background: white;\n  border-radius: inherit;\n  border-top-left-radius: 0;\n  border-bottom-left-radius: 0;\n  display: flex;\n  flex-direction: column;\n  height: 100%;\n  overflow: hidden;\n  overscroll-behavior: contain;\n  transition: all 0.3s ease-out-in;\n  ${({ expanded, floating }) => {\n    if (expanded) {\n      return css`\n        flex: 1;\n      `\n    }\n    if (floating) {\n      return css`\n        width: ${MAIA_FLOATING_PANEL_WIDTH_PX.default}px;\n        @media (min-width: ${MAIA_FLOATING_BREAKPOINT_LARGE}px) {\n          width: ${MAIA_FLOATING_PANEL_WIDTH_PX.large}px;\n        }\n        @media (min-width: ${MAIA_FLOATING_BREAKPOINT_XXL}px) {\n          width: ${MAIA_FLOATING_PANEL_WIDTH_PX.xxl}px;\n        }\n      `\n    }\n    return css`\n      width: 480px;\n    `\n  }}\n  ${({ floating }) =>\n    floating &&\n    css`\n      border-radius: 8px;\n      border-top-left-radius: 8px;\n      border-bottom-left-radius: 8px;\n    `}\n`\n\nexport const SCCAIMMinimizedHide = styled.div<{ $hidden: boolean }>`\n  display: ${({ $hidden }) => ($hidden ? 'none' : 'contents')};\n`\n"],"mappings":"AAAA,OAAOA,MAAM,IAAIC,GAAG,QAAQ,mBAAmB;AAE/C,SACEC,8BAA8B,EAC9BC,4BAA4B,EAC5BC,6BAA6B,EAC7BC,4BAA4B,QACvB,UAAU;AACjB,SAASC,kCAAkC,QAAQ,wCAAwC;AAE3F,OAAO,IAAMC,aAAa,GAAGP,MAAM,CAACQ,GAAG,CAAAC,UAAA;EAAAC,WAAA;EAAAC,WAAA;AAAA,4MAQnC,UAAAC,IAAA;EAAA,IAAGC,UAAU,GAAAD,IAAA,CAAVC,UAAU;EAAA,OACbA,UAAU,IACVZ,GAAG,0BAEF;AAAA,GAGQ,UAAAa,KAAA;EAAA,IAAGC,QAAQ,GAAAD,KAAA,CAARC,QAAQ;EAAA,OAAQA,QAAQ,GAAGT,kCAAkC,GAAG,IAAI;AAAA,CAAC,EAUjF,UAAAU,KAAA;EAAA,IAAGC,QAAQ,GAAAD,KAAA,CAARC,QAAQ;EAAA,OACXA,QAAQ,IACRhB,GAAG,gDAKF;AAAA,GACD,UAAAiB,KAAA;EAAA,IAAGC,UAAU,GAAAD,KAAA,CAAVC,UAAU;IAAEC,YAAY,GAAAF,KAAA,CAAZE,YAAY;IAAEH,QAAQ,GAAAC,KAAA,CAARD,QAAQ;EAAA,OACrCE,UAAU,KAAK,UAAU,IACzBC,YAAY,IACZ,CAACH,QAAQ,IACThB,GAAG,4JACMmB,YAAY,CAACC,CAAC,EACbD,YAAY,CAACE,CAAC,CASvB;AAAA,EACJ;AAED,OAAO,IAAMC,oBAAoB,GAAGvB,MAAM,CAACQ,GAAG,CAAAC,UAAA;EAAAC,WAAA;EAAAC,WAAA;AAAA,mMAY1C,UAAAa,KAAA;EAAA,IAAGP,QAAQ,GAAAO,KAAA,CAARP,QAAQ;EAAA,OAAQA,QAAQ,GAAG;IAAEQ,KAAK,EAAE;EAAO,CAAC,GAAG,CAAC,CAAC;AAAA,CAAC,EACrD,UAAAC,KAAA;EAAA,IAAGC,QAAQ,GAAAD,KAAA,CAARC,QAAQ;EAAA,OACXA,QAAQ,IACR1B,GAAG,uHACSG,6BAA6B,WAAQ,EAE1BF,8BAA8B,EACvCE,6BAA6B,CAACwB,KAAK,EAE1BzB,4BAA4B,EACrCC,6BAA6B,CAACyB,GAAG,CAE9C;AAAA,EACJ;AAED,OAAO,IAAMC,aAAa,GAAG9B,MAAM,CAACQ,GAAG,CAAAC,UAAA;EAAAC,WAAA;EAAAC,WAAA;AAAA,yOAcnC,UAAAoB,KAAA,EAA4B;EAAA,IAAzBd,QAAQ,GAAAc,KAAA,CAARd,QAAQ;IAAEU,QAAQ,GAAAI,KAAA,CAARJ,QAAQ;EACrB,IAAIV,QAAQ,EAAE;IACZ,OAAOhB,GAAG;EAGZ;EACA,IAAI0B,QAAQ,EAAE;IACZ,OAAO1B,GAAG,oGACCI,4BAA4B,WAAQ,EACxBH,8BAA8B,EACxCG,4BAA4B,CAACuB,KAAK,EAExBzB,4BAA4B,EACtCE,4BAA4B,CAACwB,GAAG;EAG/C;EACA,OAAO5B,GAAG;AAGZ,CAAC,EACC,UAAA+B,KAAA;EAAA,IAAGL,QAAQ,GAAAK,KAAA,CAARL,QAAQ;EAAA,OACXA,QAAQ,IACR1B,GAAG,iFAIF;AAAA,EACJ;AAED,OAAO,IAAMgC,mBAAmB,GAAGjC,MAAM,CAACQ,GAAG,CAAAC,UAAA;EAAAC,WAAA;EAAAC,WAAA;AAAA,sBAChC,UAAAuB,KAAA;EAAA,IAAGC,OAAO,GAAAD,KAAA,CAAPC,OAAO;EAAA,OAAQA,OAAO,GAAG,MAAM,GAAG,UAAU;AAAA,CAAC,CAC5D","ignoreList":[]}

package/lib/components/molecules/ChatAIModal/components/ChatAiAgentOptions/ChatAiAgentOptions.js

@@ -10,7 +10,6 @@ import { EVENTS, useEvent } from '../../../../../hooks/useEvent';
 import { validateIsMaia } from '../../../../../services/utils/validateIsMaia';
 import { useToggleFavorite } from '../../../../../hooks';
 import { MAIAIcon } from '../../../../atoms/icons';
-import { useUsageStore } from '../../../../../store/useUsageStore';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export var ChatAIAgentOption = function ChatAIAgentOption(_ref) {
   var _user$permissions;
@@ -30,9 +29,6 @@ export var ChatAIAgentOption = function ChatAIAgentOption(_ref) {
     showTooltip = _useResizeListener.showTooltip;
   var _useToggleFavorite = useToggleFavorite(),
     toggleFavorite = _useToggleFavorite.toggleFavorite;
-  var usageBlocked = useUsageStore(function (state) {
-    return state.blocked;
-  });
   var userPermissions = user === null || user === void 0 || (_user$permissions = user.permissions) === null || _user$permissions === void 0 ? void 0 : _user$permissions.ai_agents;
   var canEditCustomAgent = (userPermissions === null || userPermissions === void 0 ? void 0 : userPermissions.edit) && !validateIsMaia(agent) && agent.type === 'custom' && window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS;
   var handleClick = function handleClick(event) {
@@ -79,12 +75,9 @@ export var ChatAIAgentOption = function ChatAIAgentOption(_ref) {
         children: [canEditCustomAgent && /*#__PURE__*/_jsx(Tooltip, {
           title: t('agents.edit'),
           children: /*#__PURE__*/_jsx(SCCAIAOWrapperEdit, {
-            $disabled: usageBlocked,
-            "aria-disabled": usageBlocked,
             onClick: function onClick(e) {
               e.stopPropagation();
               e.preventDefault();
-              if (usageBlocked) return;
               setIsExpanded === null || setIsExpanded === void 0 || setIsExpanded(false);
               amplitudEvent(EVENTS.openModal, {
                 option: 'edit_agent'
@@ -131,4 +124,4 @@ export var ChatAIAgentOption = function ChatAIAgentOption(_ref) {
     })]
   }, "agent-".concat(index));
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useRef","Tooltip","Pencil","Star","useTranslation","useResizeListener","SCCAIAOWrapper","SCCAIAOWrapperEdit","SCCAIMAgentName","SCCAIMWrapperAgentName","useUser","EVENTS","useEvent","validateIsMaia","useToggleFavorite","MAIAIcon","useUsageStore","jsx","_jsx","jsxs","_jsxs","ChatAIAgentOption","_ref","_user$permissions","agent","index","handleSelectAgent","isSelected","isMaia","onFavoriteToggle","setIsExpanded","_useTranslation","t","user","amplitudEvent","agentRef","_useResizeListener","name","showTooltip","_useToggleFavorite","toggleFavorite","usageBlocked","state","blocked","userPermissions","permissions","ai_agents","canEditCustomAgent","edit","type","window","MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS","handleClick","event","preventDefault","stopPropagation","handleToggleFavorite","id","updatedAgent","aiChatFavorite","option","is_favorite","undefined","$index","onClick","children","emoji","title","ref","hasCorruptedAccess","has_corrupted_access","style","display","gap","alignItems","$disabled","e","openModal","document","dispatchEvent","CustomEvent","detail","agentValues","values","isEditing","knowledge","general","isOpen","width","height","color","className","alwaysVisible","fill","variant","concat"],"sources":["../../../../../../src/components/molecules/ChatAIModal/components/ChatAiAgentOptions/ChatAiAgentOptions.tsx"],"sourcesContent":["import { useRef, MouseEvent } from 'react'\nimport { Tooltip } from '@projectcor/tooltipv2/lib/components/Tooltip'\nimport { Pencil } from '@projectcor/icons/lib/components/Pencil'\nimport { Star } from '@projectcor/icons/lib/components/Star'\nimport { useTranslation } from 'react-i18next'\nimport { Agent } from '../../../../../types/agent'\nimport { useResizeListener } from '../../../../../hooks/useResize'\nimport {\n  SCCAIAOWrapper,\n  SCCAIAOWrapperEdit,\n  SCCAIMAgentName,\n  SCCAIMWrapperAgentName,\n} from './ChatAiAgentOptions.styles'\nimport { useUser } from '../../../../../context/cor-user'\nimport { EVENTS, useEvent } from '../../../../../hooks/useEvent'\nimport { validateIsMaia } from '../../../../../services/utils/validateIsMaia'\nimport { useToggleFavorite } from '../../../../../hooks'\nimport { MAIAIcon } from '../../../../atoms/icons'\nimport { useUsageStore } from '../../../../../store/useUsageStore'\n\nexport const ChatAIAgentOption = ({\n  agent,\n  index,\n  handleSelectAgent,\n  isSelected,\n  isMaia,\n  onFavoriteToggle,\n  setIsExpanded,\n}: {\n  agent: Agent\n  index: number\n  handleSelectAgent: (agent: Agent) => void\n  isSelected: boolean\n  isMaia?: boolean\n  onFavoriteToggle?: (updatedAgent: Agent) => void\n  setIsExpanded?: (isExpanded: boolean) => void\n}) => {\n  const { t } = useTranslation(['chat_ai_section'])\n  const user = useUser()\n  const amplitudEvent = useEvent()\n  const agentRef = useRef<HTMLSpanElement>(null)\n  const { showTooltip } = useResizeListener(agentRef, [agent.name])\n  const { toggleFavorite } = useToggleFavorite()\n\n  const usageBlocked = useUsageStore(state => state.blocked)\n  const userPermissions = user?.permissions?.ai_agents\n  const canEditCustomAgent =\n    userPermissions?.edit &&\n    !validateIsMaia(agent as Agent) &&\n    agent.type === 'custom' &&\n    window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS\n\n  const handleClick = (event: MouseEvent<HTMLDivElement>) => {\n    event.preventDefault()\n    event.stopPropagation()\n    handleSelectAgent(agent)\n  }\n\n  const handleToggleFavorite = (event: MouseEvent<HTMLDivElement>) => {\n    event.preventDefault()\n    event.stopPropagation()\n\n    toggleFavorite(\n      agent.id,\n      updatedAgent => {\n        if (onFavoriteToggle) {\n          onFavoriteToggle(updatedAgent)\n        }\n        amplitudEvent(EVENTS.aiChatFavorite, { option: updatedAgent.is_favorite ? 'add' : 'remove' })\n      },\n      undefined,\n      agent.is_favorite\n    )\n  }\n\n  return (\n    <SCCAIAOWrapper key={`agent-${index}`} $index={index} isSelected={isSelected} onClick={handleClick} isMaia={isMaia}>\n      {agent.type === 'custom' && <span>{agent?.emoji}</span>}\n      {agent.type === 'orchestrator' && (\n        <span>\n          <MAIAIcon />\n        </span>\n      )}\n      <SCCAIMWrapperAgentName>\n        <Tooltip title={showTooltip ? agent?.name : ''}>\n          <SCCAIMAgentName ref={agentRef} isSelected={isSelected} hasCorruptedAccess={!!agent?.has_corrupted_access}>\n            {agent?.name}\n          </SCCAIMAgentName>\n        </Tooltip>\n        <div style={{ display: 'flex', gap: '4px', alignItems: 'center' }}>\n          {canEditCustomAgent && (\n            <Tooltip title={t('agents.edit')}>\n              <SCCAIAOWrapperEdit\n                $disabled={usageBlocked}\n                aria-disabled={usageBlocked}\n                onClick={e => {\n                  e.stopPropagation()\n                  e.preventDefault()\n                  if (usageBlocked) return\n                  setIsExpanded?.(false)\n                  amplitudEvent(EVENTS.openModal, { option: 'edit_agent' })\n                  document.dispatchEvent(\n                    new CustomEvent('abm-agent-modal-set-values', {\n                      detail: {\n                        agentValues: {\n                          values: {\n                            isEditing: true,\n                            knowledge: agent?.knowledge || [],\n                            general: {\n                              name: agent.name,\n                              id: agent.id,\n                            },\n                          },\n                          isOpen: true,\n                        },\n                      },\n                    })\n                  )\n                }}\n              >\n                <Pencil width={20} height={20} color=\"#a6a6a6\" className=\"pencil-icon\" />\n              </SCCAIAOWrapperEdit>\n            </Tooltip>\n          )}\n          {!validateIsMaia(agent as Agent) && (\n            <Tooltip title={agent?.is_favorite ? t('agents.removeFavorite') : t('agents.addFavorite')}>\n              <SCCAIAOWrapperEdit alwaysVisible={agent?.is_favorite} onClick={handleToggleFavorite}>\n                <Star\n                  width={20}\n                  height={20}\n                  color={agent?.is_favorite ? '#FFC624' : '#a6a6a6'}\n                  fill={agent?.is_favorite ? '#FFC624' : 'none'}\n                  variant=\"solid\"\n                  className={agent?.is_favorite ? '' : 'star-favorite-icon'}\n                />\n              </SCCAIAOWrapperEdit>\n            </Tooltip>\n          )}\n        </div>\n      </SCCAIMWrapperAgentName>\n    </SCCAIAOWrapper>\n  )\n}\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useRef","Tooltip","Pencil","Star","useTranslation","useResizeListener","SCCAIAOWrapper","SCCAIAOWrapperEdit","SCCAIMAgentName","SCCAIMWrapperAgentName","useUser","EVENTS","useEvent","validateIsMaia","useToggleFavorite","MAIAIcon","jsx","_jsx","jsxs","_jsxs","ChatAIAgentOption","_ref","_user$permissions","agent","index","handleSelectAgent","isSelected","isMaia","onFavoriteToggle","setIsExpanded","_useTranslation","t","user","amplitudEvent","agentRef","_useResizeListener","name","showTooltip","_useToggleFavorite","toggleFavorite","userPermissions","permissions","ai_agents","canEditCustomAgent","edit","type","window","MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS","handleClick","event","preventDefault","stopPropagation","handleToggleFavorite","id","updatedAgent","aiChatFavorite","option","is_favorite","undefined","$index","onClick","children","emoji","title","ref","hasCorruptedAccess","has_corrupted_access","style","display","gap","alignItems","e","openModal","document","dispatchEvent","CustomEvent","detail","agentValues","values","isEditing","knowledge","general","isOpen","width","height","color","className","alwaysVisible","fill","variant","concat"],"sources":["../../../../../../src/components/molecules/ChatAIModal/components/ChatAiAgentOptions/ChatAiAgentOptions.tsx"],"sourcesContent":["import { useRef, MouseEvent } from 'react'\nimport { Tooltip } from '@projectcor/tooltipv2/lib/components/Tooltip'\nimport { Pencil } from '@projectcor/icons/lib/components/Pencil'\nimport { Star } from '@projectcor/icons/lib/components/Star'\nimport { useTranslation } from 'react-i18next'\nimport { Agent } from '../../../../../types/agent'\nimport { useResizeListener } from '../../../../../hooks/useResize'\nimport {\n  SCCAIAOWrapper,\n  SCCAIAOWrapperEdit,\n  SCCAIMAgentName,\n  SCCAIMWrapperAgentName,\n} from './ChatAiAgentOptions.styles'\nimport { useUser } from '../../../../../context/cor-user'\nimport { EVENTS, useEvent } from '../../../../../hooks/useEvent'\nimport { validateIsMaia } from '../../../../../services/utils/validateIsMaia'\nimport { useToggleFavorite } from '../../../../../hooks'\nimport { MAIAIcon } from '../../../../atoms/icons'\n\nexport const ChatAIAgentOption = ({\n  agent,\n  index,\n  handleSelectAgent,\n  isSelected,\n  isMaia,\n  onFavoriteToggle,\n  setIsExpanded,\n}: {\n  agent: Agent\n  index: number\n  handleSelectAgent: (agent: Agent) => void\n  isSelected: boolean\n  isMaia?: boolean\n  onFavoriteToggle?: (updatedAgent: Agent) => void\n  setIsExpanded?: (isExpanded: boolean) => void\n}) => {\n  const { t } = useTranslation(['chat_ai_section'])\n  const user = useUser()\n  const amplitudEvent = useEvent()\n  const agentRef = useRef<HTMLSpanElement>(null)\n  const { showTooltip } = useResizeListener(agentRef, [agent.name])\n  const { toggleFavorite } = useToggleFavorite()\n\n  const userPermissions = user?.permissions?.ai_agents\n  const canEditCustomAgent =\n    userPermissions?.edit &&\n    !validateIsMaia(agent as Agent) &&\n    agent.type === 'custom' &&\n    window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS\n\n  const handleClick = (event: MouseEvent<HTMLDivElement>) => {\n    event.preventDefault()\n    event.stopPropagation()\n    handleSelectAgent(agent)\n  }\n\n  const handleToggleFavorite = (event: MouseEvent<HTMLDivElement>) => {\n    event.preventDefault()\n    event.stopPropagation()\n\n    toggleFavorite(\n      agent.id,\n      updatedAgent => {\n        if (onFavoriteToggle) {\n          onFavoriteToggle(updatedAgent)\n        }\n        amplitudEvent(EVENTS.aiChatFavorite, { option: updatedAgent.is_favorite ? 'add' : 'remove' })\n      },\n      undefined,\n      agent.is_favorite\n    )\n  }\n\n  return (\n    <SCCAIAOWrapper key={`agent-${index}`} $index={index} isSelected={isSelected} onClick={handleClick} isMaia={isMaia}>\n      {agent.type === 'custom' && <span>{agent?.emoji}</span>}\n      {agent.type === 'orchestrator' && (\n        <span>\n          <MAIAIcon />\n        </span>\n      )}\n      <SCCAIMWrapperAgentName>\n        <Tooltip title={showTooltip ? agent?.name : ''}>\n          <SCCAIMAgentName ref={agentRef} isSelected={isSelected} hasCorruptedAccess={!!agent?.has_corrupted_access}>\n            {agent?.name}\n          </SCCAIMAgentName>\n        </Tooltip>\n        <div style={{ display: 'flex', gap: '4px', alignItems: 'center' }}>\n          {canEditCustomAgent && (\n            <Tooltip title={t('agents.edit')}>\n              <SCCAIAOWrapperEdit\n                onClick={e => {\n                  e.stopPropagation()\n                  e.preventDefault()\n                  setIsExpanded?.(false)\n                  amplitudEvent(EVENTS.openModal, { option: 'edit_agent' })\n                  document.dispatchEvent(\n                    new CustomEvent('abm-agent-modal-set-values', {\n                      detail: {\n                        agentValues: {\n                          values: {\n                            isEditing: true,\n                            knowledge: agent?.knowledge || [],\n                            general: {\n                              name: agent.name,\n                              id: agent.id,\n                            },\n                          },\n                          isOpen: true,\n                        },\n                      },\n                    })\n                  )\n                }}\n              >\n                <Pencil width={20} height={20} color=\"#a6a6a6\" className=\"pencil-icon\" />\n              </SCCAIAOWrapperEdit>\n            </Tooltip>\n          )}\n          {!validateIsMaia(agent as Agent) && (\n            <Tooltip title={agent?.is_favorite ? t('agents.removeFavorite') : t('agents.addFavorite')}>\n              <SCCAIAOWrapperEdit alwaysVisible={agent?.is_favorite} onClick={handleToggleFavorite}>\n                <Star\n                  width={20}\n                  height={20}\n                  color={agent?.is_favorite ? '#FFC624' : '#a6a6a6'}\n                  fill={agent?.is_favorite ? '#FFC624' : 'none'}\n                  variant=\"solid\"\n                  className={agent?.is_favorite ? '' : 'star-favorite-icon'}\n                />\n              </SCCAIAOWrapperEdit>\n            </Tooltip>\n          )}\n        </div>\n      </SCCAIMWrapperAgentName>\n    </SCCAIAOWrapper>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/components/molecules/ChatAIModal/components/ChatAiAgentOptions/ChatAiAgentOptions.styles.js

@@ -5,24 +5,18 @@ import { cascadeItem } from '../../../../../styles/cascade';
 export var SCCAIAOWrapperEdit = styled.div.withConfig({
   displayName: "ChatAiAgentOptionsstyles__SCCAIAOWrapperEdit",
   componentId: "sc-rn7dbh-0"
-})(["display:", ";align-items:center;justify-content:center;cursor:", ";opacity:", ";&:hover .star-favorite-icon path[fill]{fill:#666666 !important;}&:hover .star-favorite-icon g[fill]{fill:#666666 !important;}&:hover .star-favorite-icon *{fill:#666666 !important;}&:hover .pencil-icon path[fill]{fill:#666666 !important;}"], function (_ref) {
+})(["display:", ";align-items:center;justify-content:center;cursor:pointer;&:hover .star-favorite-icon path[fill]{fill:#666666 !important;}&:hover .star-favorite-icon g[fill]{fill:#666666 !important;}&:hover .star-favorite-icon *{fill:#666666 !important;}&:hover .pencil-icon path[fill]{fill:#666666 !important;}"], function (_ref) {
   var alwaysVisible = _ref.alwaysVisible;
   return alwaysVisible ? 'flex' : 'none';
-}, function (_ref2) {
-  var $disabled = _ref2.$disabled;
-  return $disabled ? 'not-allowed' : 'pointer';
-}, function (_ref3) {
-  var $disabled = _ref3.$disabled;
-  return $disabled ? 0.5 : 1;
 });
 export var SCCAIAOWrapper = styled.div.withConfig({
   displayName: "ChatAiAgentOptionsstyles__SCCAIAOWrapper",
   componentId: "sc-rn7dbh-1"
-})(["display:flex;align-items:center;gap:6px;padding:8px 12px;width:100%;background-color:", ";border-radius:4px;", " &:hover{background-color:", ";", "{display:flex;}}"], function (_ref4) {
-  var isSelected = _ref4.isSelected;
+})(["display:flex;align-items:center;gap:6px;padding:8px 12px;width:100%;background-color:", ";border-radius:4px;", " &:hover{background-color:", ";", "{display:flex;}}"], function (_ref2) {
+  var isSelected = _ref2.isSelected;
   return isSelected ? BLUE_IA_COLORS[50] : 'transparent';
-}, function (_ref5) {
-  var $index = _ref5.$index;
+}, function (_ref3) {
+  var $index = _ref3.$index;
   return cascadeItem($index);
 }, BLUE_IA_COLORS[50], SCCAIAOWrapperEdit);
 export var SCCAIMWrapperAgentName = styled.div.withConfig({
@@ -32,9 +26,9 @@ export var SCCAIMWrapperAgentName = styled.div.withConfig({
 export var SCCAIMAgentName = styled.span.withConfig({
   displayName: "ChatAiAgentOptionsstyles__SCCAIMAgentName",
   componentId: "sc-rn7dbh-3"
-})(["overflow:hidden;text-overflow:ellipsis;white-space:nowrap;display:block;width:100%;color:", ";"], function (_ref6) {
-  var isSelected = _ref6.isSelected,
-    hasCorruptedAccess = _ref6.hasCorruptedAccess;
+})(["overflow:hidden;text-overflow:ellipsis;white-space:nowrap;display:block;width:100%;color:", ";"], function (_ref4) {
+  var isSelected = _ref4.isSelected,
+    hasCorruptedAccess = _ref4.hasCorruptedAccess;
   return hasCorruptedAccess ? '#A20404' : isSelected ? BLUE_IA_COLORS[900] : 'rgba(102, 102, 102, 1)';
 });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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