@projectcor/maia-components 2.44.5 → 2.45.1-0

package/lib/hooks/useChatManager/useChatManager.spec.js

@@ -0,0 +1,1261 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook } from '@testing-library/react';
+import { GlobalContextTestProvider, testAgent } from '../../test/global-context';
+import { useSessionsStore } from '../../store/sessions/useSessionsStore';
+import { sessionStreamManager } from '../../store/sessions/sessionStreamManager';
+import { ChatHistoryRole } from '../../types/Chat';
+import { Feedback } from '../../components/molecules/MessageFeedback/MessageFeedback';
+import maia from '../../services/maia';
+import { activeView } from '../../store/sessions/activeView';
+import { useOrchestratorStream } from '../useOrchestratorStream';
+import { getChatsStoreState } from '../../store/useChatsStore';
+import { notifySessionFinishedInBackground } from '../../store/sessions/sessionNotifications';
+import { useChatManager } from './useChatManager';
+import { jsx as _jsx } from "react/jsx-runtime";
+var mockUseOrchestratorStream = useOrchestratorStream;
+var streamCallbacks = {};
+var startContinueStreamMock = jest.fn().mockResolvedValue({
+  started: true
+});
+var askMaiaMock = jest.fn().mockResolvedValue({
+  started: true
+});
+var retryCompletionMock = jest.fn().mockResolvedValue({
+  started: true
+});
+var stopStreamingMock = jest.fn();
+var replaceMessagesMock = jest.fn();
+var addMessageMock = jest.fn();
+var eventMock = jest.fn();
+var chatMessagesState = {
+  loadingMessages: false,
+  messages: [],
+  isLoadingMoreMessages: false,
+  loadMessages: jest.fn(),
+  addMessage: addMessageMock,
+  removeMessage: jest.fn(),
+  replaceMessages: replaceMessagesMock,
+  handleScroll: jest.fn()
+};
+jest.mock('../useChatMessages', function () {
+  return {
+    useChatMessages: function useChatMessages() {
+      return chatMessagesState;
+    }
+  };
+});
+jest.mock('../useOrchestratorStream', function () {
+  return {
+    useOrchestratorStream: jest.fn()
+  };
+});
+jest.mock('../useProjects', function () {
+  return {
+    useProjects: function useProjects() {
+      return {
+        fetchProjects: jest.fn().mockResolvedValue([])
+      };
+    }
+  };
+});
+jest.mock('../useTabTaskDefault', function () {
+  return {
+    useTabTaskDefault: function useTabTaskDefault() {
+      return {
+        getTabTaskDefault: jest.fn().mockResolvedValue('detail')
+      };
+    }
+  };
+});
+jest.mock('../useEvent', function () {
+  return {
+    EVENTS: {
+      pmAiTypedText: 'PM_AI_TYPED_TEXT'
+    },
+    useEvent: function useEvent() {
+      return eventMock;
+    }
+  };
+});
+jest.mock('../../context/cor-user', function () {
+  return {
+    useUser: function useUser() {
+      return {
+        id: 7,
+        firstName: 'Ana',
+        lastName: 'García',
+        picture: 'pic.png',
+        lang: 'es',
+        company_id: 10
+      };
+    }
+  };
+});
+jest.mock('../../store/useChatsStore', function () {
+  var state = {
+    setActiveChatId: jest.fn(),
+    markChatAsRead: jest.fn(),
+    markChatAsUnread: jest.fn(),
+    isChatViewVisible: true,
+    chats: [],
+    prependChat: jest.fn()
+  };
+  var useChatsStore = function useChatsStore(selector) {
+    return selector(state);
+  };
+  Object.assign(useChatsStore, {
+    getState: function getState() {
+      return state;
+    }
+  });
+  return {
+    useChatsStore: useChatsStore,
+    getChatsStoreState: function getChatsStoreState() {
+      return state;
+    }
+  };
+});
+jest.mock('../../services/maia', function () {
+  return {
+    __esModule: true,
+    "default": {
+      Chats: {
+        wasHelpfulChat: jest.fn()
+      }
+    }
+  };
+});
+jest.mock('../../services/maia/Agents/fetchAgentDetail', function () {
+  return {
+    fetchAgentDetail: jest.fn()
+  };
+});
+jest.mock('../../store/sessions/sessionNotifications', function () {
+  return {
+    notifySessionFinishedInBackground: jest.fn(),
+    ensureSessionNotificationsInitialized: jest.fn()
+  };
+});
+jest.mock('../../store/sessions/sessionStreamManager', function () {
+  return {
+    sessionStreamManager: {
+      isActive: jest.fn(function () {
+        return false;
+      }),
+      getActiveCount: jest.fn(function () {
+        return 0;
+      }),
+      startStream: jest.fn(),
+      startContinueStream: function startContinueStream() {
+        return startContinueStreamMock.apply(void 0, arguments);
+      },
+      stopStream: jest.fn()
+    },
+    MAX_CONCURRENT_STREAMS: 3
+  };
+});
+var wrapper = function wrapper(_ref) {
+  var children = _ref.children;
+  return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+    value: {
+      agent: testAgent
+    },
+    children: children
+  });
+};
+describe('useChatManager', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    streamCallbacks = {};
+    mockUseOrchestratorStream.mockImplementation(function (options) {
+      streamCallbacks = {
+        onError: options.onError,
+        onStreamUpdate: options.onStreamUpdate,
+        onFinishStream: options.onFinishStream
+      };
+      return {
+        askMaia: askMaiaMock,
+        retryCompletion: retryCompletionMock,
+        isLoading: false,
+        isWriting: false,
+        loadingMessage: '',
+        streamActivity: null,
+        updateStreamActivity: jest.fn(),
+        stopStreaming: stopStreamingMock
+      };
+    });
+    chatMessagesState.loadingMessages = false;
+    chatMessagesState.messages = [];
+    useSessionsStore.setState({
+      meta: {},
+      messages: {},
+      viewCache: {}
+    });
+    activeView.set(null);
+    sessionStreamManager.isActive.mockReturnValue(false);
+    sessionStreamManager.getActiveCount.mockReturnValue(0);
+    startContinueStreamMock.mockResolvedValue({
+      started: true
+    });
+    askMaiaMock.mockResolvedValue({
+      started: true
+    });
+    retryCompletionMock.mockResolvedValue({
+      started: true
+    });
+  });
+  it('starts with empty messages and send enabled', function () {
+    var _renderHook = renderHook(function () {
+        return useChatManager({
+          chatId: 'session-1',
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper
+      }),
+      result = _renderHook.result;
+    expect(result.current.messages).toEqual([]);
+    expect(result.current.isDisabled).toBe(false);
+  });
+  it('sendMessage delegates to askMaia with the current session', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _renderHook2, result;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _renderHook2 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook2.result;
+          _context2.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+            return _regeneratorRuntime.wrap(function (_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 1;
+                  return result.current.sendMessage('Hola MAIA');
+                case 1:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Hola MAIA',
+            chatId: 'session-1',
+            agentId: testAgent.id,
+            agentName: testAgent.name
+          }));
+          expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Hola MAIA',
+            role: 'user'
+          }));
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('does not send when the concurrent stream limit is reached', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var dispatchSpy, _renderHook3, result;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          ;
+          sessionStreamManager.getActiveCount.mockReturnValue(3);
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          _renderHook3 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook3.result;
+          _context4.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+            return _regeneratorRuntime.wrap(function (_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 1;
+                  return result.current.sendMessage('Hola');
+                case 1:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+        case 1:
+          expect(askMaiaMock).not.toHaveBeenCalled();
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event'
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('stopGeneration stops the active stream', function () {
+    var _renderHook4 = renderHook(function () {
+        return useChatManager({
+          chatId: 'session-1',
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper
+      }),
+      result = _renderHook4.result;
+    act(function () {
+      result.current.stopGeneration();
+    });
+    expect(stopStreamingMock).toHaveBeenCalled();
+  });
+  it('resetChat clears the active chat id in the store hook path', function () {
+    var _renderHook5 = renderHook(function () {
+        return useChatManager({
+          chatId: 'session-1',
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper
+      }),
+      result = _renderHook5.result;
+    act(function () {
+      result.current.resetChat();
+    });
+    expect(result.current.currentChatId).not.toBe('session-1');
+  });
+  it('does not send while messages are loading', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+    var _renderHook6, result;
+    return _regeneratorRuntime.wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          chatMessagesState.loadingMessages = true;
+          _renderHook6 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook6.result;
+          expect(result.current.isDisabled).toBe(true);
+          _context6.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+            return _regeneratorRuntime.wrap(function (_context5) {
+              while (1) switch (_context5.prev = _context5.next) {
+                case 0:
+                  _context5.next = 1;
+                  return result.current.sendMessage('Hola');
+                case 1:
+                case "end":
+                  return _context5.stop();
+              }
+            }, _callee5);
+          })));
+        case 1:
+          expect(askMaiaMock).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  it('includes context mentions when they are sent via options', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+    var _renderHook7, result;
+    return _regeneratorRuntime.wrap(function (_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          _renderHook7 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook7.result;
+          _context8.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+            return _regeneratorRuntime.wrap(function (_context7) {
+              while (1) switch (_context7.prev = _context7.next) {
+                case 0:
+                  _context7.next = 1;
+                  return result.current.sendMessage('Hola', {
+                    mentions: [{
+                      id: 'u1',
+                      type: 'user',
+                      label: 'Ana'
+                    }]
+                  });
+                case 1:
+                case "end":
+                  return _context7.stop();
+              }
+            }, _callee7);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            contextMessage: expect.objectContaining({
+              user: expect.arrayContaining([expect.objectContaining({
+                id: 'u1',
+                name: 'Ana'
+              })])
+            })
+          }));
+          expect(eventMock).toHaveBeenCalledWith('PM_AI_TYPED_TEXT');
+        case 2:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+  it('retries a cancelled assistant turn through askMaia', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0() {
+    var _renderHook8, result;
+    return _regeneratorRuntime.wrap(function (_context0) {
+      while (1) switch (_context0.prev = _context0.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'question-1',
+            message: 'Hola',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date()
+          }, {
+            id: 'answer-stream-1-cancelled',
+            message: 'Respuesta parcial',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'Assistant'
+            },
+            date: new Date(),
+            isFrontendCancelled: true
+          }];
+          _renderHook8 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook8.result;
+          _context0.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+            return _regeneratorRuntime.wrap(function (_context9) {
+              while (1) switch (_context9.prev = _context9.next) {
+                case 0:
+                  _context9.next = 1;
+                  return result.current.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context9.stop();
+              }
+            }, _callee9);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Hola',
+            chatId: 'session-1'
+          }));
+          expect(replaceMessagesMock).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context0.stop();
+      }
+    }, _callee0);
+  })));
+  it('re-asks with the new project when a pending question exists', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+    var setProject, project, _renderHook9, result;
+    return _regeneratorRuntime.wrap(function (_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          setProject = jest.fn();
+          project = {
+            id: 10,
+            name: 'Proyecto A'
+          };
+          _renderHook9 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: function wrapper(_ref11) {
+              var children = _ref11.children;
+              return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+                value: {
+                  agent: testAgent,
+                  project: project,
+                  setProject: setProject
+                },
+                children: children
+              });
+            }
+          }), result = _renderHook9.result;
+          _context10.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee1() {
+            return _regeneratorRuntime.wrap(function (_context1) {
+              while (1) switch (_context1.prev = _context1.next) {
+                case 0:
+                  _context1.next = 1;
+                  return result.current.sendMessage('¿Cuántas horas van?');
+                case 1:
+                case "end":
+                  return _context1.stop();
+              }
+            }, _callee1);
+          })));
+        case 1:
+          askMaiaMock.mockClear();
+          act(function () {
+            result.current.changeProject({
+              id: 99,
+              name: 'Proyecto X',
+              feeId: 5,
+              clientId: 7
+            });
+          });
+          expect(setProject).toHaveBeenCalledWith(expect.objectContaining({
+            id: 99
+          }));
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: '¿Cuántas horas van?',
+            projectId: 99,
+            feeId: 5,
+            clientId: 7
+          }));
+        case 2:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee10);
+  })));
+  it('does not change project when there is no pending user question', function () {
+    var _renderHook0 = renderHook(function () {
+        return useChatManager({
+          chatId: 'session-1',
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper
+      }),
+      result = _renderHook0.result;
+    act(function () {
+      result.current.changeProject({
+        id: 99,
+        name: 'Proyecto X'
+      });
+    });
+    expect(askMaiaMock).not.toHaveBeenCalled();
+  });
+  it('starts a continue stream when rejecting a HITL action', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee12() {
+    var _renderHook1, result;
+    return _regeneratorRuntime.wrap(function (_context12) {
+      while (1) switch (_context12.prev = _context12.next) {
+        case 0:
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'msg-approval',
+            message: 'Approve task edit?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'thread-a',
+                tool_name: 'edit_task',
+                tool_args: {
+                  task_id: 42
+                }
+              }]
+            }
+          }];
+          _renderHook1 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook1.result;
+          _context12.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee11() {
+            return _regeneratorRuntime.wrap(function (_context11) {
+              while (1) switch (_context11.prev = _context11.next) {
+                case 0:
+                  _context11.next = 1;
+                  return result.current.handleApprovalDecision(['thread-a'], 'reject');
+                case 1:
+                case "end":
+                  return _context11.stop();
+              }
+            }, _callee11);
+          })));
+        case 1:
+          expect(startContinueStreamMock).toHaveBeenCalledWith(expect.objectContaining({
+            continueRequest: expect.objectContaining({
+              decision: 'reject'
+            })
+          }));
+        case 2:
+        case "end":
+          return _context12.stop();
+      }
+    }, _callee12);
+  })));
+  it('starts a continue stream when approving a HITL action', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee14() {
+    var _renderHook10, result;
+    return _regeneratorRuntime.wrap(function (_context14) {
+      while (1) switch (_context14.prev = _context14.next) {
+        case 0:
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'msg-approval',
+            message: 'Approve task edit?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'thread-a',
+                tool_name: 'edit_task',
+                tool_args: {
+                  task_id: 42
+                }
+              }]
+            }
+          }];
+          _renderHook10 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook10.result;
+          _context14.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee13() {
+            return _regeneratorRuntime.wrap(function (_context13) {
+              while (1) switch (_context13.prev = _context13.next) {
+                case 0:
+                  _context13.next = 1;
+                  return result.current.handleApprovalDecision(['thread-a'], 'approve');
+                case 1:
+                case "end":
+                  return _context13.stop();
+              }
+            }, _callee13);
+          })));
+        case 1:
+          expect(startContinueStreamMock).toHaveBeenCalledWith(expect.objectContaining({
+            sessionId: 'session-1',
+            continueRequest: expect.objectContaining({
+              threadIds: ['thread-a'],
+              decision: 'approve'
+            })
+          }));
+        case 2:
+        case "end":
+          return _context14.stop();
+      }
+    }, _callee14);
+  })));
+  it('submits feedback through the maia chats service', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee16() {
+    var _renderHook11, result;
+    return _regeneratorRuntime.wrap(function (_context16) {
+      while (1) switch (_context16.prev = _context16.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'answer-1',
+            message: 'Respuesta',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'Assistant'
+            },
+            date: new Date()
+          }];
+          jest.mocked(maia.Chats.wasHelpfulChat).mockResolvedValue(true);
+          _renderHook11 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook11.result;
+          _context16.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee15() {
+            return _regeneratorRuntime.wrap(function (_context15) {
+              while (1) switch (_context15.prev = _context15.next) {
+                case 0:
+                  _context15.next = 1;
+                  return result.current.handleFeedback(Feedback.THUMBS_UP, 'answer-1');
+                case 1:
+                case "end":
+                  return _context15.stop();
+              }
+            }, _callee15);
+          })));
+        case 1:
+          expect(maia.Chats.wasHelpfulChat).toHaveBeenCalledWith('answer-1', true);
+        case 2:
+        case "end":
+          return _context16.stop();
+      }
+    }, _callee16);
+  })));
+  it('ignores feedback updates when the API rejects the vote', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee18() {
+    var _renderHook12, result;
+    return _regeneratorRuntime.wrap(function (_context18) {
+      while (1) switch (_context18.prev = _context18.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'answer-1',
+            message: 'Respuesta',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'Assistant'
+            },
+            date: new Date()
+          }];
+          jest.mocked(maia.Chats.wasHelpfulChat).mockResolvedValue(false);
+          _renderHook12 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook12.result;
+          _context18.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee17() {
+            return _regeneratorRuntime.wrap(function (_context17) {
+              while (1) switch (_context17.prev = _context17.next) {
+                case 0:
+                  _context17.next = 1;
+                  return result.current.handleFeedback(Feedback.THUMBS_DOWN, 'answer-1');
+                case 1:
+                case "end":
+                  return _context17.stop();
+              }
+            }, _callee17);
+          })));
+        case 1:
+          expect(chatMessagesState.messages[0]).not.toHaveProperty('wasHelpful');
+        case 2:
+        case "end":
+          return _context18.stop();
+      }
+    }, _callee18);
+  })));
+  it('does not start approval streams without thread ids', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee20() {
+    var consoleSpy, _renderHook13, result;
+    return _regeneratorRuntime.wrap(function (_context20) {
+      while (1) switch (_context20.prev = _context20.next) {
+        case 0:
+          consoleSpy = jest.spyOn(console, 'error').mockImplementation(function () {
+            return undefined;
+          });
+          _renderHook13 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook13.result;
+          _context20.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee19() {
+            return _regeneratorRuntime.wrap(function (_context19) {
+              while (1) switch (_context19.prev = _context19.next) {
+                case 0:
+                  _context19.next = 1;
+                  return result.current.handleApprovalDecision([], 'approve');
+                case 1:
+                case "end":
+                  return _context19.stop();
+              }
+            }, _callee19);
+          })));
+        case 1:
+          expect(startContinueStreamMock).not.toHaveBeenCalled();
+          expect(consoleSpy).toHaveBeenCalled();
+          consoleSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context20.stop();
+      }
+    }, _callee20);
+  })));
+  it('sendMessage accepts a bare attachments array', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee22() {
+    var attachment, _renderHook14, result;
+    return _regeneratorRuntime.wrap(function (_context22) {
+      while (1) switch (_context22.prev = _context22.next) {
+        case 0:
+          attachment = {
+            id: 'a1',
+            name: 'doc.pdf',
+            type: 'pdf',
+            size: 1,
+            file: new File([], 'doc.pdf')
+          };
+          _renderHook14 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook14.result;
+          _context22.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee21() {
+            return _regeneratorRuntime.wrap(function (_context21) {
+              while (1) switch (_context21.prev = _context21.next) {
+                case 0:
+                  _context21.next = 1;
+                  return result.current.sendMessage('Con adjunto', [attachment]);
+                case 1:
+                case "end":
+                  return _context21.stop();
+              }
+            }, _callee21);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Con adjunto',
+            attachments: [attachment]
+          }));
+        case 2:
+        case "end":
+          return _context22.stop();
+      }
+    }, _callee22);
+  })));
+  it('loads messages when initializeChat runs with an existing chat id', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee24() {
+    var _renderHook15, result;
+    return _regeneratorRuntime.wrap(function (_context24) {
+      while (1) switch (_context24.prev = _context24.next) {
+        case 0:
+          chatMessagesState.loadMessages.mockResolvedValue(undefined);
+          _renderHook15 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook15.result;
+          _context24.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee23() {
+            return _regeneratorRuntime.wrap(function (_context23) {
+              while (1) switch (_context23.prev = _context23.next) {
+                case 0:
+                  _context23.next = 1;
+                  return result.current.initializeChat();
+                case 1:
+                case "end":
+                  return _context23.stop();
+              }
+            }, _callee23);
+          })));
+        case 1:
+          expect(chatMessagesState.loadMessages).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context24.stop();
+      }
+    }, _callee24);
+  })));
+  it('auto-sends the initial FAQ when initializeChat receives faqId only', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee26() {
+    var _renderHook16, result;
+    return _regeneratorRuntime.wrap(function (_context26) {
+      while (1) switch (_context26.prev = _context26.next) {
+        case 0:
+          _renderHook16 = renderHook(function () {
+            return useChatManager({
+              userInitialMessage: {
+                message: '',
+                attachments: [],
+                faqId: 'faq-rentabilidad'
+              },
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook16.result;
+          _context26.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee25() {
+            return _regeneratorRuntime.wrap(function (_context25) {
+              while (1) switch (_context25.prev = _context25.next) {
+                case 0:
+                  _context25.next = 1;
+                  return result.current.initializeChat();
+                case 1:
+                case "end":
+                  return _context25.stop();
+              }
+            }, _callee25);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            faqId: 'faq-rentabilidad'
+          }));
+        case 2:
+        case "end":
+          return _context26.stop();
+      }
+    }, _callee26);
+  })));
+  it('skips initializeChat auto-send when the initial payload is empty', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee28() {
+    var _renderHook17, result;
+    return _regeneratorRuntime.wrap(function (_context28) {
+      while (1) switch (_context28.prev = _context28.next) {
+        case 0:
+          _renderHook17 = renderHook(function () {
+            return useChatManager({
+              userInitialMessage: {
+                message: '   ',
+                attachments: []
+              },
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook17.result;
+          _context28.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee27() {
+            return _regeneratorRuntime.wrap(function (_context27) {
+              while (1) switch (_context27.prev = _context27.next) {
+                case 0:
+                  _context27.next = 1;
+                  return result.current.initializeChat();
+                case 1:
+                case "end":
+                  return _context27.stop();
+              }
+            }, _callee27);
+          })));
+        case 1:
+          expect(askMaiaMock).not.toHaveBeenCalled();
+          expect(chatMessagesState.loadMessages).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context28.stop();
+      }
+    }, _callee28);
+  })));
+  it('does not retry when the concurrent stream limit is reached', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee30() {
+    var dispatchSpy, _renderHook18, result;
+    return _regeneratorRuntime.wrap(function (_context30) {
+      while (1) switch (_context30.prev = _context30.next) {
+        case 0:
+          ;
+          sessionStreamManager.getActiveCount.mockReturnValue(3);
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          chatMessagesState.messages = [{
+            id: 'question-1',
+            message: 'Hola',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date()
+          }, {
+            id: 'answer-stream-1-cancelled',
+            message: 'Respuesta parcial',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'Assistant'
+            },
+            date: new Date(),
+            isFrontendCancelled: true
+          }];
+          _renderHook18 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook18.result;
+          _context30.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee29() {
+            return _regeneratorRuntime.wrap(function (_context29) {
+              while (1) switch (_context29.prev = _context29.next) {
+                case 0:
+                  _context29.next = 1;
+                  return result.current.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context29.stop();
+              }
+            }, _callee29);
+          })));
+        case 1:
+          expect(askMaiaMock).not.toHaveBeenCalled();
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event'
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context30.stop();
+      }
+    }, _callee30);
+  })));
+  it('does not start approval streams when the session is already streaming', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee32() {
+    var _renderHook19, result;
+    return _regeneratorRuntime.wrap(function (_context32) {
+      while (1) switch (_context32.prev = _context32.next) {
+        case 0:
+          activeView.set('session-1');
+          sessionStreamManager.isActive.mockReturnValue(true);
+          chatMessagesState.messages = [{
+            id: 'msg-approval',
+            message: 'Approve?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'thread-a',
+                tool_name: 'edit_task',
+                tool_args: {}
+              }]
+            }
+          }];
+          _renderHook19 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook19.result;
+          _context32.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee31() {
+            return _regeneratorRuntime.wrap(function (_context31) {
+              while (1) switch (_context31.prev = _context31.next) {
+                case 0:
+                  _context31.next = 1;
+                  return result.current.handleApprovalDecision(['thread-a'], 'approve');
+                case 1:
+                case "end":
+                  return _context31.stop();
+              }
+            }, _callee31);
+          })));
+        case 1:
+          expect(startContinueStreamMock).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context32.stop();
+      }
+    }, _callee32);
+  })));
+  it('starts a continue stream with edit decision when actions were edited', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee34() {
+    var editedActions, _renderHook20, result;
+    return _regeneratorRuntime.wrap(function (_context34) {
+      while (1) switch (_context34.prev = _context34.next) {
+        case 0:
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'msg-approval',
+            message: 'Approve task edit?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'thread-a',
+                tool_name: 'edit_task',
+                tool_args: {
+                  task_id: 42
+                }
+              }]
+            }
+          }];
+          editedActions = [{
+            tool_name: 'edit_task',
+            args: {
+              task_id: 99
+            }
+          }];
+          _renderHook20 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook20.result;
+          _context34.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee33() {
+            return _regeneratorRuntime.wrap(function (_context33) {
+              while (1) switch (_context33.prev = _context33.next) {
+                case 0:
+                  _context33.next = 1;
+                  return result.current.handleApprovalDecision(['thread-a'], 'reject', editedActions);
+                case 1:
+                case "end":
+                  return _context33.stop();
+              }
+            }, _callee33);
+          })));
+        case 1:
+          expect(startContinueStreamMock).toHaveBeenCalledWith(expect.objectContaining({
+            continueRequest: expect.objectContaining({
+              decision: 'edit',
+              editedActions: editedActions
+            })
+          }));
+        case 2:
+        case "end":
+          return _context34.stop();
+      }
+    }, _callee34);
+  })));
+  it('commits access denied stream errors without retry suggestions', function () {
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onEr, _streamCallbacks;
+      (_streamCallbacks$onEr = (_streamCallbacks = streamCallbacks).onError) === null || _streamCallbacks$onEr === void 0 || _streamCallbacks$onEr.call(_streamCallbacks, {
+        sessionId: 'session-1',
+        messageId: 'msg-err',
+        placeholderId: 'answer-msg-err-streaming'
+      }, "Access denied: You don't have permission to access this agent");
+    });
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      isError: true,
+      message: 'chat.errorAccessDenied'
+    }));
+    expect(addMessageMock).not.toHaveBeenCalledWith(expect.objectContaining({
+      suggestions: ['chat.retry']
+    }));
+  });
+  it('adds retry suggestions for generic stream errors on the active session', function () {
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onEr2, _streamCallbacks2;
+      (_streamCallbacks$onEr2 = (_streamCallbacks2 = streamCallbacks).onError) === null || _streamCallbacks$onEr2 === void 0 || _streamCallbacks$onEr2.call(_streamCallbacks2, {
+        sessionId: 'session-1',
+        messageId: 'msg-500',
+        placeholderId: 'answer-msg-500-streaming'
+      }, 'server_error');
+    });
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      isError: true,
+      suggestions: ['chat.retry']
+    }));
+  });
+  it('creates the streaming placeholder on the first stream update', function () {
+    activeView.set('session-1');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    var ctx = {
+      sessionId: 'session-1',
+      messageId: 'live-1',
+      placeholderId: 'answer-live-1-streaming'
+    };
+    act(function () {
+      var _streamCallbacks$onSt, _streamCallbacks3;
+      (_streamCallbacks$onSt = (_streamCallbacks3 = streamCallbacks).onStreamUpdate) === null || _streamCallbacks$onSt === void 0 || _streamCallbacks$onSt.call(_streamCallbacks3, ctx, 'Generando');
+    });
+    expect(useSessionsStore.getState().getMessages('session-1')).toEqual(expect.arrayContaining([expect.objectContaining({
+      id: 'answer-live-1-streaming',
+      message: ''
+    })]));
+  });
+  it('marks background sessions unread when a stream finishes off-screen', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee36() {
+    return _regeneratorRuntime.wrap(function (_context36) {
+      while (1) switch (_context36.prev = _context36.next) {
+        case 0:
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          activeView.set('session-visible');
+          _context36.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee35() {
+            var _streamCallbacks$onFi, _streamCallbacks4;
+            return _regeneratorRuntime.wrap(function (_context35) {
+              while (1) switch (_context35.prev = _context35.next) {
+                case 0:
+                  _context35.next = 1;
+                  return (_streamCallbacks$onFi = (_streamCallbacks4 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi === void 0 ? void 0 : _streamCallbacks$onFi.call(_streamCallbacks4, {
+                    sessionId: 'session-1',
+                    messageId: 'bg-1',
+                    placeholderId: 'answer-bg-1-streaming'
+                  }, 'Respuesta en background', [], 'memory-bg-1', null, null, null);
+                case 1:
+                case "end":
+                  return _context35.stop();
+              }
+            }, _callee35);
+          })));
+        case 1:
+          expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-1');
+          expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-1', 'complete');
+          expect(addMessageMock).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context36.stop();
+      }
+    }, _callee36);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","GlobalContextTestProvider","testAgent","useSessionsStore","sessionStreamManager","ChatHistoryRole","Feedback","maia","activeView","useOrchestratorStream","getChatsStoreState","notifySessionFinishedInBackground","useChatManager","jsx","_jsx","mockUseOrchestratorStream","streamCallbacks","startContinueStreamMock","jest","fn","mockResolvedValue","started","askMaiaMock","retryCompletionMock","stopStreamingMock","replaceMessagesMock","addMessageMock","eventMock","chatMessagesState","loadingMessages","messages","isLoadingMoreMessages","loadMessages","addMessage","removeMessage","replaceMessages","handleScroll","mock","useChatMessages","useProjects","fetchProjects","useTabTaskDefault","getTabTaskDefault","EVENTS","pmAiTypedText","useEvent","useUser","id","firstName","lastName","picture","lang","company_id","state","setActiveChatId","markChatAsRead","markChatAsUnread","isChatViewVisible","chats","prependChat","useChatsStore","selector","Object","assign","getState","__esModule","Chats","wasHelpfulChat","fetchAgentDetail","ensureSessionNotificationsInitialized","isActive","getActiveCount","startStream","startContinueStream","apply","arguments","stopStream","MAX_CONCURRENT_STREAMS","wrapper","_ref","children","value","agent","describe","beforeEach","clearAllMocks","mockImplementation","options","onError","onStreamUpdate","onFinishStream","askMaia","retryCompletion","isLoading","isWriting","loadingMessage","streamActivity","updateStreamActivity","stopStreaming","setState","meta","viewCache","set","mockReturnValue","it","_renderHook","chatId","agents","result","expect","current","toEqual","isDisabled","toBe","_asyncToGenerator","_regeneratorRuntime","mark","_callee2","_renderHook2","wrap","_context2","prev","next","_callee","_context","sendMessage","stop","toHaveBeenCalledWith","objectContaining","message","agentId","agentName","name","role","_callee4","dispatchSpy","_renderHook3","_context4","spyOn","document","_callee3","_context3","not","toHaveBeenCalled","type","mockRestore","_renderHook4","stopGeneration","_renderHook5","resetChat","currentChatId","_callee6","_renderHook6","_context6","_callee5","_context5","_callee8","_renderHook7","_context8","_callee7","_context7","mentions","label","contextMessage","user","arrayContaining","_callee0","_renderHook8","_context0","USER","date","Date","ASSISTANT","isFrontendCancelled","_callee9","_context9","retryMessage","_callee10","setProject","project","_renderHook9","_context10","_ref11","_callee1","_context1","mockClear","changeProject","feeId","clientId","projectId","_renderHook0","_callee12","_renderHook1","_context12","approval","session_id","pending_actions","thread_id","tool_name","tool_args","task_id","_callee11","_context11","handleApprovalDecision","continueRequest","decision","_callee14","_renderHook10","_context14","_callee13","_context13","sessionId","threadIds","_callee16","_renderHook11","_context16","mocked","_callee15","_context15","handleFeedback","THUMBS_UP","_callee18","_renderHook12","_context18","_callee17","_context17","THUMBS_DOWN","toHaveProperty","_callee20","consoleSpy","_renderHook13","_context20","console","undefined","_callee19","_context19","_callee22","attachment","_renderHook14","_context22","size","file","File","_callee21","_context21","attachments","_callee24","_renderHook15","_context24","_callee23","_context23","initializeChat","_callee26","_renderHook16","_context26","userInitialMessage","faqId","_callee25","_context25","_callee28","_renderHook17","_context28","_callee27","_context27","_callee30","_renderHook18","_context30","_callee29","_context29","_callee32","_renderHook19","_context32","_callee31","_context31","_callee34","editedActions","_renderHook20","_context34","args","_callee33","_context33","_streamCallbacks$onEr","_streamCallbacks","call","messageId","placeholderId","isError","suggestions","_streamCallbacks$onEr2","_streamCallbacks2","ctx","_streamCallbacks$onSt","_streamCallbacks3","getMessages","_callee36","_context36","_callee35","_streamCallbacks$onFi","_streamCallbacks4","_context35"],"sources":["../../../src/hooks/useChatManager/useChatManager.spec.tsx"],"sourcesContent":["import { ReactNode } from 'react'\nimport { act, renderHook } from '@testing-library/react'\nimport { GlobalContextTestProvider, testAgent } from '../../test/global-context'\nimport { useSessionsStore } from '../../store/sessions/useSessionsStore'\nimport { sessionStreamManager } from '../../store/sessions/sessionStreamManager'\nimport { ChatHistoryRole, ChatMessage } from '../../types/Chat'\nimport { Feedback } from '../../components/molecules/MessageFeedback/MessageFeedback'\nimport maia from '../../services/maia'\nimport { activeView } from '../../store/sessions/activeView'\nimport { useOrchestratorStream } from '../useOrchestratorStream'\nimport type { StreamContext } from '../useOrchestratorStream/useOrchestratorStream.interface'\nimport { getChatsStoreState } from '../../store/useChatsStore'\nimport { notifySessionFinishedInBackground } from '../../store/sessions/sessionNotifications'\nimport { useChatManager } from './useChatManager'\n\nconst mockUseOrchestratorStream = useOrchestratorStream as jest.MockedFunction<typeof useOrchestratorStream>\n\ntype CapturedStreamCallbacks = {\n  onError?: (ctx: StreamContext, errorMessage?: string, errorRawMessage?: string) => void\n  onStreamUpdate?: (ctx: StreamContext, content: string) => void\n  onFinishStream?: (\n    ctx: StreamContext,\n    content: string,\n    sources: unknown,\n    memorySessionId: string,\n    attachments?: unknown[] | null,\n    suggestions?: string[] | null,\n    agentId?: string | null\n  ) => void | Promise<void>\n}\n\nlet streamCallbacks: CapturedStreamCallbacks = {}\n\nconst startContinueStreamMock = jest.fn().mockResolvedValue({ started: true })\n\nconst askMaiaMock = jest.fn().mockResolvedValue({ started: true })\nconst retryCompletionMock = jest.fn().mockResolvedValue({ started: true })\nconst stopStreamingMock = jest.fn()\nconst replaceMessagesMock = jest.fn()\nconst addMessageMock = jest.fn()\nconst eventMock = jest.fn()\n\nconst chatMessagesState = {\n  loadingMessages: false,\n  messages: [] as ChatMessage[],\n  isLoadingMoreMessages: false,\n  loadMessages: jest.fn(),\n  addMessage: addMessageMock,\n  removeMessage: jest.fn(),\n  replaceMessages: replaceMessagesMock,\n  handleScroll: jest.fn(),\n}\n\njest.mock('../useChatMessages', () => ({\n  useChatMessages: () => chatMessagesState,\n}))\n\njest.mock('../useOrchestratorStream', () => ({\n  useOrchestratorStream: jest.fn(),\n}))\n\njest.mock('../useProjects', () => ({\n  useProjects: () => ({\n    fetchProjects: jest.fn().mockResolvedValue([]),\n  }),\n}))\n\njest.mock('../useTabTaskDefault', () => ({\n  useTabTaskDefault: () => ({\n    getTabTaskDefault: jest.fn().mockResolvedValue('detail'),\n  }),\n}))\n\njest.mock('../useEvent', () => ({\n  EVENTS: { pmAiTypedText: 'PM_AI_TYPED_TEXT' },\n  useEvent: () => eventMock,\n}))\n\njest.mock('../../context/cor-user', () => ({\n  useUser: () => ({\n    id: 7,\n    firstName: 'Ana',\n    lastName: 'García',\n    picture: 'pic.png',\n    lang: 'es',\n    company_id: 10,\n  }),\n}))\n\njest.mock('../../store/useChatsStore', () => {\n  const state = {\n    setActiveChatId: jest.fn(),\n    markChatAsRead: jest.fn(),\n    markChatAsUnread: jest.fn(),\n    isChatViewVisible: true,\n    chats: [] as Array<{ sessionExternalId: string }>,\n    prependChat: jest.fn(),\n  }\n  const useChatsStore = (selector: (value: typeof state) => unknown) => selector(state)\n  Object.assign(useChatsStore, { getState: () => state })\n\n  return {\n    useChatsStore,\n    getChatsStoreState: () => state,\n  }\n})\n\njest.mock('../../services/maia', () => ({\n  __esModule: true,\n  default: {\n    Chats: {\n      wasHelpfulChat: jest.fn(),\n    },\n  },\n}))\n\njest.mock('../../services/maia/Agents/fetchAgentDetail', () => ({\n  fetchAgentDetail: jest.fn(),\n}))\n\njest.mock('../../store/sessions/sessionNotifications', () => ({\n  notifySessionFinishedInBackground: jest.fn(),\n  ensureSessionNotificationsInitialized: jest.fn(),\n}))\n\njest.mock('../../store/sessions/sessionStreamManager', () => ({\n  sessionStreamManager: {\n    isActive: jest.fn(() => false),\n    getActiveCount: jest.fn(() => 0),\n    startStream: jest.fn(),\n    startContinueStream: (...args: unknown[]) => startContinueStreamMock(...args),\n    stopStream: jest.fn(),\n  },\n  MAX_CONCURRENT_STREAMS: 3,\n}))\n\nconst wrapper = ({ children }: { children: ReactNode }) => (\n  <GlobalContextTestProvider value={{ agent: testAgent }}>{children}</GlobalContextTestProvider>\n)\n\ndescribe('useChatManager', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n    streamCallbacks = {}\n    mockUseOrchestratorStream.mockImplementation(options => {\n      streamCallbacks = {\n        onError: options.onError,\n        onStreamUpdate: options.onStreamUpdate,\n        onFinishStream: options.onFinishStream,\n      }\n      return {\n        askMaia: askMaiaMock,\n        retryCompletion: retryCompletionMock,\n        isLoading: false,\n        isWriting: false,\n        loadingMessage: '',\n        streamActivity: null,\n        updateStreamActivity: jest.fn(),\n        stopStreaming: stopStreamingMock,\n      }\n    })\n    chatMessagesState.loadingMessages = false\n    chatMessagesState.messages = []\n    useSessionsStore.setState({ meta: {}, messages: {}, viewCache: {} })\n    activeView.set(null)\n    ;(sessionStreamManager.isActive as jest.Mock).mockReturnValue(false)\n    ;(sessionStreamManager.getActiveCount as jest.Mock).mockReturnValue(0)\n    startContinueStreamMock.mockResolvedValue({ started: true })\n    askMaiaMock.mockResolvedValue({ started: true })\n    retryCompletionMock.mockResolvedValue({ started: true })\n  })\n\n  it('starts with empty messages and send enabled', () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    expect(result.current.messages).toEqual([])\n    expect(result.current.isDisabled).toBe(false)\n  })\n\n  it('sendMessage delegates to askMaia with the current session', async () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.sendMessage('Hola MAIA')\n    })\n\n    expect(askMaiaMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        message: 'Hola MAIA',\n        chatId: 'session-1',\n        agentId: testAgent.id,\n        agentName: testAgent.name,\n      })\n    )\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        message: 'Hola MAIA',\n        role: 'user',\n      })\n    )\n  })\n\n  it('does not send when the concurrent stream limit is reached', async () => {\n    ;(sessionStreamManager.getActiveCount as jest.Mock).mockReturnValue(3)\n    const dispatchSpy = jest.spyOn(document, 'dispatchEvent')\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.sendMessage('Hola')\n    })\n\n    expect(askMaiaMock).not.toHaveBeenCalled()\n    expect(dispatchSpy).toHaveBeenCalledWith(\n      expect.objectContaining({\n        type: 'snackbar-event',\n      })\n    )\n\n    dispatchSpy.mockRestore()\n  })\n\n  it('stopGeneration stops the active stream', () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      result.current.stopGeneration()\n    })\n\n    expect(stopStreamingMock).toHaveBeenCalled()\n  })\n\n  it('resetChat clears the active chat id in the store hook path', () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      result.current.resetChat()\n    })\n\n    expect(result.current.currentChatId).not.toBe('session-1')\n  })\n\n  it('does not send while messages are loading', async () => {\n    chatMessagesState.loadingMessages = true\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    expect(result.current.isDisabled).toBe(true)\n\n    await act(async () => {\n      await result.current.sendMessage('Hola')\n    })\n\n    expect(askMaiaMock).not.toHaveBeenCalled()\n  })\n\n  it('includes context mentions when they are sent via options', async () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.sendMessage('Hola', {\n        mentions: [{ id: 'u1', type: 'user', label: 'Ana' }],\n      })\n    })\n\n    expect(askMaiaMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        contextMessage: expect.objectContaining({\n          user: expect.arrayContaining([expect.objectContaining({ id: 'u1', name: 'Ana' })]),\n        }),\n      })\n    )\n    expect(eventMock).toHaveBeenCalledWith('PM_AI_TYPED_TEXT')\n  })\n\n  it('retries a cancelled assistant turn through askMaia', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'question-1',\n        message: 'Hola',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n      },\n      {\n        id: 'answer-stream-1-cancelled',\n        message: 'Respuesta parcial',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'Assistant' },\n        date: new Date(),\n        isFrontendCancelled: true,\n      },\n    ]\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.retryMessage(chatMessagesState.messages[1])\n    })\n\n    expect(askMaiaMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        message: 'Hola',\n        chatId: 'session-1',\n      })\n    )\n    expect(replaceMessagesMock).toHaveBeenCalled()\n  })\n\n  it('re-asks with the new project when a pending question exists', async () => {\n    const setProject = jest.fn()\n    const project = { id: 10, name: 'Proyecto A' } as never\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      {\n        wrapper: ({ children }: { children: ReactNode }) => (\n          <GlobalContextTestProvider value={{ agent: testAgent, project, setProject }}>\n            {children}\n          </GlobalContextTestProvider>\n        ),\n      }\n    )\n\n    await act(async () => {\n      await result.current.sendMessage('¿Cuántas horas van?')\n    })\n\n    askMaiaMock.mockClear()\n\n    act(() => {\n      result.current.changeProject({ id: 99, name: 'Proyecto X', feeId: 5, clientId: 7 } as never)\n    })\n\n    expect(setProject).toHaveBeenCalledWith(expect.objectContaining({ id: 99 }))\n    expect(askMaiaMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        message: '¿Cuántas horas van?',\n        projectId: 99,\n        feeId: 5,\n        clientId: 7,\n      })\n    )\n  })\n\n  it('does not change project when there is no pending user question', () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      result.current.changeProject({ id: 99, name: 'Proyecto X' } as never)\n    })\n\n    expect(askMaiaMock).not.toHaveBeenCalled()\n  })\n\n  it('starts a continue stream when rejecting a HITL action', async () => {\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'msg-approval',\n        message: 'Approve task edit?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'thread-a', tool_name: 'edit_task', tool_args: { task_id: 42 } }],\n        },\n      },\n    ]\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleApprovalDecision(['thread-a'], 'reject')\n    })\n\n    expect(startContinueStreamMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        continueRequest: expect.objectContaining({\n          decision: 'reject',\n        }),\n      })\n    )\n  })\n\n  it('starts a continue stream when approving a HITL action', async () => {\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'msg-approval',\n        message: 'Approve task edit?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'thread-a', tool_name: 'edit_task', tool_args: { task_id: 42 } }],\n        },\n      },\n    ]\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleApprovalDecision(['thread-a'], 'approve')\n    })\n\n    expect(startContinueStreamMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        sessionId: 'session-1',\n        continueRequest: expect.objectContaining({\n          threadIds: ['thread-a'],\n          decision: 'approve',\n        }),\n      })\n    )\n  })\n\n  it('submits feedback through the maia chats service', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'answer-1',\n        message: 'Respuesta',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'Assistant' },\n        date: new Date(),\n      },\n    ]\n\n    jest.mocked(maia.Chats.wasHelpfulChat).mockResolvedValue(true)\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleFeedback(Feedback.THUMBS_UP, 'answer-1')\n    })\n\n    expect(maia.Chats.wasHelpfulChat).toHaveBeenCalledWith('answer-1', true)\n  })\n\n  it('ignores feedback updates when the API rejects the vote', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'answer-1',\n        message: 'Respuesta',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'Assistant' },\n        date: new Date(),\n      },\n    ]\n\n    jest.mocked(maia.Chats.wasHelpfulChat).mockResolvedValue(false)\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleFeedback(Feedback.THUMBS_DOWN, 'answer-1')\n    })\n\n    expect(chatMessagesState.messages[0]).not.toHaveProperty('wasHelpful')\n  })\n\n  it('does not start approval streams without thread ids', async () => {\n    const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined)\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleApprovalDecision([], 'approve')\n    })\n\n    expect(startContinueStreamMock).not.toHaveBeenCalled()\n    expect(consoleSpy).toHaveBeenCalled()\n\n    consoleSpy.mockRestore()\n  })\n\n  it('sendMessage accepts a bare attachments array', async () => {\n    const attachment = { id: 'a1', name: 'doc.pdf', type: 'pdf', size: 1, file: new File([], 'doc.pdf') }\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.sendMessage('Con adjunto', [attachment])\n    })\n\n    expect(askMaiaMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        message: 'Con adjunto',\n        attachments: [attachment],\n      })\n    )\n  })\n\n  it('loads messages when initializeChat runs with an existing chat id', async () => {\n    chatMessagesState.loadMessages.mockResolvedValue(undefined)\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.initializeChat()\n    })\n\n    expect(chatMessagesState.loadMessages).toHaveBeenCalled()\n  })\n\n  it('auto-sends the initial FAQ when initializeChat receives faqId only', async () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          userInitialMessage: { message: '', attachments: [], faqId: 'faq-rentabilidad' },\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.initializeChat()\n    })\n\n    expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({ faqId: 'faq-rentabilidad' }))\n  })\n\n  it('skips initializeChat auto-send when the initial payload is empty', async () => {\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          userInitialMessage: { message: '   ', attachments: [] },\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.initializeChat()\n    })\n\n    expect(askMaiaMock).not.toHaveBeenCalled()\n    expect(chatMessagesState.loadMessages).not.toHaveBeenCalled()\n  })\n\n  it('does not retry when the concurrent stream limit is reached', async () => {\n    ;(sessionStreamManager.getActiveCount as jest.Mock).mockReturnValue(3)\n    const dispatchSpy = jest.spyOn(document, 'dispatchEvent')\n\n    chatMessagesState.messages = [\n      {\n        id: 'question-1',\n        message: 'Hola',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n      },\n      {\n        id: 'answer-stream-1-cancelled',\n        message: 'Respuesta parcial',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'Assistant' },\n        date: new Date(),\n        isFrontendCancelled: true,\n      },\n    ]\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.retryMessage(chatMessagesState.messages[1])\n    })\n\n    expect(askMaiaMock).not.toHaveBeenCalled()\n    expect(dispatchSpy).toHaveBeenCalledWith(\n      expect.objectContaining({\n        type: 'snackbar-event',\n      })\n    )\n\n    dispatchSpy.mockRestore()\n  })\n\n  it('does not start approval streams when the session is already streaming', async () => {\n    activeView.set('session-1')\n    ;(sessionStreamManager.isActive as jest.Mock).mockReturnValue(true)\n    chatMessagesState.messages = [\n      {\n        id: 'msg-approval',\n        message: 'Approve?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'thread-a', tool_name: 'edit_task', tool_args: {} }],\n        },\n      },\n    ]\n\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleApprovalDecision(['thread-a'], 'approve')\n    })\n\n    expect(startContinueStreamMock).not.toHaveBeenCalled()\n  })\n\n  it('starts a continue stream with edit decision when actions were edited', async () => {\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'msg-approval',\n        message: 'Approve task edit?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'thread-a', tool_name: 'edit_task', tool_args: { task_id: 42 } }],\n        },\n      },\n    ]\n\n    const editedActions = [{ tool_name: 'edit_task', args: { task_id: 99 } }]\n    const { result } = renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await result.current.handleApprovalDecision(['thread-a'], 'reject', editedActions)\n    })\n\n    expect(startContinueStreamMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        continueRequest: expect.objectContaining({\n          decision: 'edit',\n          editedActions,\n        }),\n      })\n    )\n  })\n\n  it('commits access denied stream errors without retry suggestions', () => {\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onError?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'msg-err',\n          placeholderId: 'answer-msg-err-streaming',\n        },\n        \"Access denied: You don't have permission to access this agent\"\n      )\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        isError: true,\n        message: 'chat.errorAccessDenied',\n      })\n    )\n    expect(addMessageMock).not.toHaveBeenCalledWith(\n      expect.objectContaining({\n        suggestions: ['chat.retry'],\n      })\n    )\n  })\n\n  it('adds retry suggestions for generic stream errors on the active session', () => {\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onError?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'msg-500',\n          placeholderId: 'answer-msg-500-streaming',\n        },\n        'server_error'\n      )\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        isError: true,\n        suggestions: ['chat.retry'],\n      })\n    )\n  })\n\n  it('creates the streaming placeholder on the first stream update', () => {\n    activeView.set('session-1')\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    const ctx: StreamContext = {\n      sessionId: 'session-1',\n      messageId: 'live-1',\n      placeholderId: 'answer-live-1-streaming',\n    }\n\n    act(() => {\n      streamCallbacks.onStreamUpdate?.(ctx, 'Generando')\n    })\n\n    expect(useSessionsStore.getState().getMessages('session-1')).toEqual(\n      expect.arrayContaining([expect.objectContaining({ id: 'answer-live-1-streaming', message: '' })])\n    )\n  })\n\n  it('marks background sessions unread when a stream finishes off-screen', async () => {\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    activeView.set('session-visible')\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'bg-1',\n          placeholderId: 'answer-bg-1-streaming',\n        },\n        'Respuesta en background',\n        [],\n        'memory-bg-1',\n        null,\n        null,\n        null\n      )\n    })\n\n    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-1')\n    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-1', 'complete')\n    expect(addMessageMock).not.toHaveBeenCalled()\n  })\n})\n"],"mappings":"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","ignoreList":[]}