@projectcor/maia-components 2.51.1 → 2.52.1-0

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

@@ -0,0 +1,2467 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+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 _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 { fetchAgentDetail } from '../../services/maia/Agents/fetchAgentDetail';
+import { MAIA_HOURS_CHARGED_EVENT } from '../../constants/plannerSyncEvents';
+import { streamingPlaceholderMessageId } from '../../utils/streamActivityMessages';
+import { useMultipleChoiceStore } from '../../store/useMultipleChoiceStore';
+import { useChatManager } from './useChatManager';
+import { jsx as _jsx } from "react/jsx-runtime";
+var fetchAgentDetailMock = fetchAgentDetail;
+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,
+        onStop: options.onStop,
+        onApprovalRequired: options.onApprovalRequired,
+        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('marks the message that answers a multiple-choice card and consumes the answer', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _renderHook3, result;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          useMultipleChoiceStore.setState({
+            pending: {
+              messageId: 'a1',
+              question: null,
+              options: []
+            },
+            answer: null,
+            dismissedMessageIds: {}
+          });
+          useMultipleChoiceStore.getState().answerPending({
+            key: 'B'
+          });
+          _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('Proyecto Beta');
+                case 1:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenLastCalledWith(expect.objectContaining({
+            multipleChoiceAnswer: {
+              key: 'B'
+            }
+          }));
+          expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Proyecto Beta',
+            multipleChoiceAnswer: {
+              key: 'B'
+            }
+          }));
+          expect(useMultipleChoiceStore.getState().answer).toBeNull();
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('does not send when the concurrent stream limit is reached', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+    var dispatchSpy, _renderHook4, result;
+    return _regeneratorRuntime.wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          ;
+          sessionStreamManager.getActiveCount.mockReturnValue(3);
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          _renderHook4 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook4.result;
+          _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();
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event'
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  it('stopGeneration stops the active stream', function () {
+    var _renderHook5 = renderHook(function () {
+        return useChatManager({
+          chatId: 'session-1',
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper
+      }),
+      result = _renderHook5.result;
+    act(function () {
+      result.current.stopGeneration();
+    });
+    expect(stopStreamingMock).toHaveBeenCalled();
+  });
+  it('resetChat clears the active chat id in the store hook path', function () {
+    var _renderHook6 = renderHook(function () {
+        return useChatManager({
+          chatId: 'session-1',
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper
+      }),
+      result = _renderHook6.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 _callee8() {
+    var _renderHook7, result;
+    return _regeneratorRuntime.wrap(function (_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          chatMessagesState.loadingMessages = true;
+          _renderHook7 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook7.result;
+          expect(result.current.isDisabled).toBe(true);
+          _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');
+                case 1:
+                case "end":
+                  return _context7.stop();
+              }
+            }, _callee7);
+          })));
+        case 1:
+          expect(askMaiaMock).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+  it('includes context mentions when they are sent via options', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0() {
+    var _renderHook8, result;
+    return _regeneratorRuntime.wrap(function (_context0) {
+      while (1) switch (_context0.prev = _context0.next) {
+        case 0:
+          _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.sendMessage('Hola', {
+                    mentions: [{
+                      id: 'u1',
+                      type: 'user',
+                      label: 'Ana'
+                    }]
+                  });
+                case 1:
+                case "end":
+                  return _context9.stop();
+              }
+            }, _callee9);
+          })));
+        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 _context0.stop();
+      }
+    }, _callee0);
+  })));
+  it('retries a cancelled assistant turn through askMaia', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+    var _renderHook9, result;
+    return _regeneratorRuntime.wrap(function (_context10) {
+      while (1) switch (_context10.prev = _context10.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
+          }];
+          _renderHook9 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), 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.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context1.stop();
+              }
+            }, _callee1);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Hola',
+            chatId: 'session-1'
+          }));
+          expect(replaceMessagesMock).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee10);
+  })));
+  it('re-asks with the new project when a pending question exists', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee12() {
+    var setProject, project, _renderHook0, result;
+    return _regeneratorRuntime.wrap(function (_context12) {
+      while (1) switch (_context12.prev = _context12.next) {
+        case 0:
+          setProject = jest.fn();
+          project = {
+            id: 10,
+            name: 'Proyecto A'
+          };
+          _renderHook0 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: function wrapper(_ref13) {
+              var children = _ref13.children;
+              return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+                value: {
+                  agent: testAgent,
+                  project: project,
+                  setProject: setProject
+                },
+                children: children
+              });
+            }
+          }), result = _renderHook0.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.sendMessage('¿Cuántas horas van?');
+                case 1:
+                case "end":
+                  return _context11.stop();
+              }
+            }, _callee11);
+          })));
+        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 _context12.stop();
+      }
+    }, _callee12);
+  })));
+  it('does not change project when there is no pending user question', function () {
+    var _renderHook1 = renderHook(function () {
+        return useChatManager({
+          chatId: 'session-1',
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper
+      }),
+      result = _renderHook1.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 _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'], 'reject');
+                case 1:
+                case "end":
+                  return _context13.stop();
+              }
+            }, _callee13);
+          })));
+        case 1:
+          expect(startContinueStreamMock).toHaveBeenCalledWith(expect.objectContaining({
+            continueRequest: expect.objectContaining({
+              decision: 'reject'
+            })
+          }));
+        case 2:
+        case "end":
+          return _context14.stop();
+      }
+    }, _callee14);
+  })));
+  it('starts a continue stream when approving a HITL action', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee16() {
+    var _renderHook11, result;
+    return _regeneratorRuntime.wrap(function (_context16) {
+      while (1) switch (_context16.prev = _context16.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
+                }
+              }]
+            }
+          }];
+          _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.handleApprovalDecision(['thread-a'], 'approve');
+                case 1:
+                case "end":
+                  return _context15.stop();
+              }
+            }, _callee15);
+          })));
+        case 1:
+          expect(startContinueStreamMock).toHaveBeenCalledWith(expect.objectContaining({
+            sessionId: 'session-1',
+            continueRequest: expect.objectContaining({
+              threadIds: ['thread-a'],
+              decision: 'approve'
+            })
+          }));
+        case 2:
+        case "end":
+          return _context16.stop();
+      }
+    }, _callee16);
+  })));
+  it('submits feedback through the maia chats service', /*#__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(true);
+          _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_UP, 'answer-1');
+                case 1:
+                case "end":
+                  return _context17.stop();
+              }
+            }, _callee17);
+          })));
+        case 1:
+          expect(maia.Chats.wasHelpfulChat).toHaveBeenCalledWith('answer-1', true);
+        case 2:
+        case "end":
+          return _context18.stop();
+      }
+    }, _callee18);
+  })));
+  it('ignores feedback updates when the API rejects the vote', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee20() {
+    var _renderHook13, result;
+    return _regeneratorRuntime.wrap(function (_context20) {
+      while (1) switch (_context20.prev = _context20.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);
+          _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.handleFeedback(Feedback.THUMBS_DOWN, 'answer-1');
+                case 1:
+                case "end":
+                  return _context19.stop();
+              }
+            }, _callee19);
+          })));
+        case 1:
+          expect(chatMessagesState.messages[0]).not.toHaveProperty('wasHelpful');
+        case 2:
+        case "end":
+          return _context20.stop();
+      }
+    }, _callee20);
+  })));
+  it('does not start approval streams without thread ids', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee22() {
+    var consoleSpy, _renderHook14, result;
+    return _regeneratorRuntime.wrap(function (_context22) {
+      while (1) switch (_context22.prev = _context22.next) {
+        case 0:
+          consoleSpy = jest.spyOn(console, 'error').mockImplementation(function () {
+            return undefined;
+          });
+          _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.handleApprovalDecision([], 'approve');
+                case 1:
+                case "end":
+                  return _context21.stop();
+              }
+            }, _callee21);
+          })));
+        case 1:
+          expect(startContinueStreamMock).not.toHaveBeenCalled();
+          expect(consoleSpy).toHaveBeenCalled();
+          consoleSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context22.stop();
+      }
+    }, _callee22);
+  })));
+  it('sendMessage accepts a bare attachments array', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee24() {
+    var attachment, _renderHook15, result;
+    return _regeneratorRuntime.wrap(function (_context24) {
+      while (1) switch (_context24.prev = _context24.next) {
+        case 0:
+          attachment = {
+            id: 'a1',
+            name: 'doc.pdf',
+            type: 'pdf',
+            size: 1,
+            file: new File([], 'doc.pdf')
+          };
+          _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.sendMessage('Con adjunto', [attachment]);
+                case 1:
+                case "end":
+                  return _context23.stop();
+              }
+            }, _callee23);
+          })));
+        case 1:
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: 'Con adjunto',
+            attachments: [attachment]
+          }));
+        case 2:
+        case "end":
+          return _context24.stop();
+      }
+    }, _callee24);
+  })));
+  it('loads messages when initializeChat runs with an existing chat id', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee26() {
+    var _renderHook16, result;
+    return _regeneratorRuntime.wrap(function (_context26) {
+      while (1) switch (_context26.prev = _context26.next) {
+        case 0:
+          chatMessagesState.loadMessages.mockResolvedValue(undefined);
+          _renderHook16 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              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(chatMessagesState.loadMessages).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context26.stop();
+      }
+    }, _callee26);
+  })));
+  it('auto-sends the initial FAQ when initializeChat receives faqId only', /*#__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: [],
+                faqId: 'faq-rentabilidad'
+              },
+              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).toHaveBeenCalledWith(expect.objectContaining({
+            faqId: 'faq-rentabilidad'
+          }));
+        case 2:
+        case "end":
+          return _context28.stop();
+      }
+    }, _callee28);
+  })));
+  it('skips initializeChat auto-send when the initial payload is empty', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee30() {
+    var _renderHook18, result;
+    return _regeneratorRuntime.wrap(function (_context30) {
+      while (1) switch (_context30.prev = _context30.next) {
+        case 0:
+          _renderHook18 = renderHook(function () {
+            return useChatManager({
+              userInitialMessage: {
+                message: '   ',
+                attachments: []
+              },
+              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.initializeChat();
+                case 1:
+                case "end":
+                  return _context29.stop();
+              }
+            }, _callee29);
+          })));
+        case 1:
+          expect(askMaiaMock).not.toHaveBeenCalled();
+          expect(chatMessagesState.loadMessages).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context30.stop();
+      }
+    }, _callee30);
+  })));
+  it('does not retry when the concurrent stream limit is reached', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee32() {
+    var dispatchSpy, _renderHook19, result;
+    return _regeneratorRuntime.wrap(function (_context32) {
+      while (1) switch (_context32.prev = _context32.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
+          }];
+          _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.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context31.stop();
+              }
+            }, _callee31);
+          })));
+        case 1:
+          expect(askMaiaMock).not.toHaveBeenCalled();
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event'
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context32.stop();
+      }
+    }, _callee32);
+  })));
+  it('does not start approval streams when the session is already streaming', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee34() {
+    var _renderHook20, result;
+    return _regeneratorRuntime.wrap(function (_context34) {
+      while (1) switch (_context34.prev = _context34.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: {}
+              }]
+            }
+          }];
+          _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'], 'approve');
+                case 1:
+                case "end":
+                  return _context33.stop();
+              }
+            }, _callee33);
+          })));
+        case 1:
+          expect(startContinueStreamMock).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context34.stop();
+      }
+    }, _callee34);
+  })));
+  it('starts a continue stream with edit decision when actions were edited', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee36() {
+    var editedActions, _renderHook21, result;
+    return _regeneratorRuntime.wrap(function (_context36) {
+      while (1) switch (_context36.prev = _context36.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
+            }
+          }];
+          _renderHook21 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook21.result;
+          _context36.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee35() {
+            return _regeneratorRuntime.wrap(function (_context35) {
+              while (1) switch (_context35.prev = _context35.next) {
+                case 0:
+                  _context35.next = 1;
+                  return result.current.handleApprovalDecision(['thread-a'], 'reject', editedActions);
+                case 1:
+                case "end":
+                  return _context35.stop();
+              }
+            }, _callee35);
+          })));
+        case 1:
+          expect(startContinueStreamMock).toHaveBeenCalledWith(expect.objectContaining({
+            continueRequest: expect.objectContaining({
+              decision: 'edit',
+              editedActions: editedActions
+            })
+          }));
+        case 2:
+        case "end":
+          return _context36.stop();
+      }
+    }, _callee36);
+  })));
+  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('maps prompt-too-long stream errors without retry suggestions', function () {
+    activeView.set('session-1');
+    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-long',
+        placeholderId: 'answer-msg-long-streaming'
+      }, 'invalid_request_error', 'prompt is too long: 12000 tokens');
+    });
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      isError: true,
+      message: 'chat.errorPromptTooLong'
+    }));
+    expect(addMessageMock).not.toHaveBeenCalledWith(expect.objectContaining({
+      suggestions: ['chat.retry']
+    }));
+  });
+  it('marks background sessions unread when a stream errors off-screen', function () {
+    activeView.set('session-visible');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-visible',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onEr3, _streamCallbacks3;
+      (_streamCallbacks$onEr3 = (_streamCallbacks3 = streamCallbacks).onError) === null || _streamCallbacks$onEr3 === void 0 || _streamCallbacks$onEr3.call(_streamCallbacks3, {
+        sessionId: 'session-bg',
+        messageId: 'bg-err',
+        placeholderId: 'answer-bg-err-streaming'
+      }, 'server_error');
+    });
+    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-bg');
+    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-bg', 'error');
+  });
+  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$onEr4, _streamCallbacks4;
+      (_streamCallbacks$onEr4 = (_streamCallbacks4 = streamCallbacks).onError) === null || _streamCallbacks$onEr4 === void 0 || _streamCallbacks$onEr4.call(_streamCallbacks4, {
+        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, _streamCallbacks5;
+      (_streamCallbacks$onSt = (_streamCallbacks5 = streamCallbacks).onStreamUpdate) === null || _streamCallbacks$onSt === void 0 || _streamCallbacks$onSt.call(_streamCallbacks5, 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 _callee38() {
+    return _regeneratorRuntime.wrap(function (_context38) {
+      while (1) switch (_context38.prev = _context38.next) {
+        case 0:
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          activeView.set('session-visible');
+          _context38.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee37() {
+            var _streamCallbacks$onFi, _streamCallbacks6;
+            return _regeneratorRuntime.wrap(function (_context37) {
+              while (1) switch (_context37.prev = _context37.next) {
+                case 0:
+                  _context37.next = 1;
+                  return (_streamCallbacks$onFi = (_streamCallbacks6 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi === void 0 ? void 0 : _streamCallbacks$onFi.call(_streamCallbacks6, {
+                    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 _context37.stop();
+              }
+            }, _callee37);
+          })));
+        case 1:
+          expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-1');
+          expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-1', 'complete');
+          expect(addMessageMock).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context38.stop();
+      }
+    }, _callee38);
+  })));
+  it('commits prompt-too-long stream errors without retry suggestions', function () {
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onEr5, _streamCallbacks7;
+      (_streamCallbacks$onEr5 = (_streamCallbacks7 = streamCallbacks).onError) === null || _streamCallbacks$onEr5 === void 0 || _streamCallbacks$onEr5.call(_streamCallbacks7, {
+        sessionId: 'session-1',
+        messageId: 'msg-long',
+        placeholderId: 'answer-msg-long-streaming'
+      }, 'invalid_request_error', 'prompt is too long: 12000 tokens');
+    });
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      isError: true,
+      message: expect.stringContaining('chat.errorPromptTooLong')
+    }));
+    expect(addMessageMock).not.toHaveBeenCalledWith(expect.objectContaining({
+      suggestions: ['chat.retry']
+    }));
+  });
+  it('marks background sessions unread when a stream errors off-screen', function () {
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    activeView.set('other-session');
+    act(function () {
+      var _streamCallbacks$onEr6, _streamCallbacks8;
+      (_streamCallbacks$onEr6 = (_streamCallbacks8 = streamCallbacks).onError) === null || _streamCallbacks$onEr6 === void 0 || _streamCallbacks$onEr6.call(_streamCallbacks8, {
+        sessionId: 'session-1',
+        messageId: 'bg-err',
+        placeholderId: 'answer-bg-err-streaming'
+      }, 'server_error');
+    });
+    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-1');
+    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-1', 'error');
+  });
+  it('syncs task creation with the project dashboard when approval completes on the active session', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee40() {
+    var addExistingTaskToDashboard, originalPathname, taskUrl;
+    return _regeneratorRuntime.wrap(function (_context40) {
+      while (1) switch (_context40.prev = _context40.next) {
+        case 0:
+          addExistingTaskToDashboard = jest.fn();
+          window.newProjectDashboard = {
+            addExistingTaskToDashboard: addExistingTaskToDashboard
+          };
+          originalPathname = window.location.pathname;
+          Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: _objectSpread(_objectSpread({}, window.location), {}, {
+              pathname: '/projects/42/tasks'
+            })
+          });
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'user-1',
+            message: 'Crea la tarea',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date(),
+            projectId: 42
+          }, {
+            id: 'approval-msg',
+            message: '¿Confirmás?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approvalStatus: 'approved',
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 't1',
+                tool_name: 'create_task',
+                tool_args: {
+                  task_id: 55
+                }
+              }]
+            }
+          }];
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: function wrapper(_ref42) {
+              var children = _ref42.children;
+              return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+                value: {
+                  agent: testAgent,
+                  project: {
+                    id: 42,
+                    name: 'Alpha'
+                  }
+                },
+                children: children
+              });
+            }
+          });
+          taskUrl = 'https://app.cor.com/tasks/55/detail';
+          _context40.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee39() {
+            var _streamCallbacks$onFi2, _streamCallbacks9;
+            return _regeneratorRuntime.wrap(function (_context39) {
+              while (1) switch (_context39.prev = _context39.next) {
+                case 0:
+                  _context39.next = 1;
+                  return (_streamCallbacks$onFi2 = (_streamCallbacks9 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi2 === void 0 ? void 0 : _streamCallbacks$onFi2.call(_streamCallbacks9, {
+                    sessionId: 'session-1',
+                    messageId: 'live-1',
+                    placeholderId: streamingPlaceholderMessageId('live-1')
+                  }, taskUrl, [], 'memory-task-1', null, ['Seguir'], null);
+                case 1:
+                case "end":
+                  return _context39.stop();
+              }
+            }, _callee39);
+          })));
+        case 1:
+          expect(addExistingTaskToDashboard).toHaveBeenCalledWith([55]);
+          expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+            id: 'answer-memory-task-1',
+            suggestions: ['Seguir']
+          }));
+          Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: _objectSpread(_objectSpread({}, window.location), {}, {
+              pathname: originalPathname
+            })
+          });
+          delete window.newProjectDashboard;
+        case 2:
+        case "end":
+          return _context40.stop();
+      }
+    }, _callee40);
+  })));
+  it('dispatches planner sync when hours charge approval completes', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee42() {
+    var onHoursCharged, event;
+    return _regeneratorRuntime.wrap(function (_context42) {
+      while (1) switch (_context42.prev = _context42.next) {
+        case 0:
+          onHoursCharged = jest.fn();
+          window.addEventListener(MAIA_HOURS_CHARGED_EVENT, onHoursCharged);
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'approval-hours',
+            message: '¿Cargo horas?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approvalStatus: 'approved',
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'h1',
+                tool_name: 'create_hours',
+                tool_args: {}
+              }]
+            }
+          }];
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          _context42.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee41() {
+            var _streamCallbacks$onFi3, _streamCallbacks0;
+            return _regeneratorRuntime.wrap(function (_context41) {
+              while (1) switch (_context41.prev = _context41.next) {
+                case 0:
+                  _context41.next = 1;
+                  return (_streamCallbacks$onFi3 = (_streamCallbacks0 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi3 === void 0 ? void 0 : _streamCallbacks$onFi3.call(_streamCallbacks0, {
+                    sessionId: 'session-1',
+                    messageId: 'hours-1',
+                    placeholderId: streamingPlaceholderMessageId('hours-1')
+                  }, 'Horas cargadas', [], 'memory-hours-1');
+                case 1:
+                case "end":
+                  return _context41.stop();
+              }
+            }, _callee41);
+          })));
+        case 1:
+          expect(onHoursCharged).toHaveBeenCalled();
+          event = onHoursCharged.mock.calls[0][0];
+          expect(event.detail.tools).toEqual(['create_hours']);
+          window.removeEventListener(MAIA_HOURS_CHARGED_EVENT, onHoursCharged);
+        case 2:
+        case "end":
+          return _context42.stop();
+      }
+    }, _callee42);
+  })));
+  it('fetches and merges a newly created agent after stream finish', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee44() {
+    var onMergeAgent;
+    return _regeneratorRuntime.wrap(function (_context44) {
+      while (1) switch (_context44.prev = _context44.next) {
+        case 0:
+          window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = true;
+          fetchAgentDetailMock.mockResolvedValue({
+            id: 'agent-new',
+            name: 'Nuevo'
+          });
+          onMergeAgent = jest.fn();
+          document.addEventListener('maia-merge-created-agent-into-list', onMergeAgent);
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'approval-agent',
+            message: '¿Creo el agente?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approvalStatus: 'approved',
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'a1',
+                tool_name: 'create_agent',
+                tool_args: {}
+              }]
+            }
+          }];
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          _context44.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee43() {
+            var _streamCallbacks$onFi4, _streamCallbacks1;
+            return _regeneratorRuntime.wrap(function (_context43) {
+              while (1) switch (_context43.prev = _context43.next) {
+                case 0:
+                  _context43.next = 1;
+                  return (_streamCallbacks$onFi4 = (_streamCallbacks1 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi4 === void 0 ? void 0 : _streamCallbacks$onFi4.call(_streamCallbacks1, {
+                    sessionId: 'session-1',
+                    messageId: 'agent-live',
+                    placeholderId: streamingPlaceholderMessageId('agent-live')
+                  }, 'Agente creado', [], 'memory-agent-1', null, null, 'agent-new');
+                case 1:
+                  _context43.next = 2;
+                  return Promise.resolve();
+                case 2:
+                case "end":
+                  return _context43.stop();
+              }
+            }, _callee43);
+          })));
+        case 1:
+          expect(fetchAgentDetailMock).toHaveBeenCalledWith('agent-new');
+          expect(onMergeAgent).toHaveBeenCalled();
+          document.removeEventListener('maia-merge-created-agent-into-list', onMergeAgent);
+          window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = false;
+        case 2:
+        case "end":
+          return _context44.stop();
+      }
+    }, _callee44);
+  })));
+  it('refetches the open task panel after an approved task edit', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee46() {
+    var refetchTask;
+    return _regeneratorRuntime.wrap(function (_context46) {
+      while (1) switch (_context46.prev = _context46.next) {
+        case 0:
+          refetchTask = jest.fn();
+          window.taskPanel = {
+            taskId: 88,
+            refetchTask: refetchTask
+          };
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'approval-edit',
+            message: '¿Edito?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approvalStatus: 'approved',
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'e1',
+                tool_name: 'edit_task',
+                tool_args: {
+                  task_id: 88
+                }
+              }]
+            }
+          }];
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          _context46.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee45() {
+            var _streamCallbacks$onFi5, _streamCallbacks10;
+            return _regeneratorRuntime.wrap(function (_context45) {
+              while (1) switch (_context45.prev = _context45.next) {
+                case 0:
+                  _context45.next = 1;
+                  return (_streamCallbacks$onFi5 = (_streamCallbacks10 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi5 === void 0 ? void 0 : _streamCallbacks$onFi5.call(_streamCallbacks10, {
+                    sessionId: 'session-1',
+                    messageId: 'edit-live',
+                    placeholderId: streamingPlaceholderMessageId('edit-live')
+                  }, 'Tarea actualizada', [], 'memory-edit-1');
+                case 1:
+                case "end":
+                  return _context45.stop();
+              }
+            }, _callee45);
+          })));
+        case 1:
+          expect(refetchTask).toHaveBeenCalled();
+          delete window.taskPanel;
+        case 2:
+        case "end":
+          return _context46.stop();
+      }
+    }, _callee46);
+  })));
+  it('reloads messages when the active session ends with a stale streaming placeholder', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee48() {
+    return _regeneratorRuntime.wrap(function (_context48) {
+      while (1) switch (_context48.prev = _context48.next) {
+        case 0:
+          useSessionsStore.setState({
+            meta: {
+              'session-1': {
+                status: 'complete',
+                finishedAt: '2024-06-01T00:00:00.000Z'
+              }
+            },
+            messages: {
+              'session-1': [{
+                id: streamingPlaceholderMessageId('stale'),
+                message: '',
+                role: ChatHistoryRole.ASSISTANT,
+                user: {
+                  id: 'assistant',
+                  name: 'MAIA'
+                },
+                date: new Date()
+              }]
+            }
+          });
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          _context48.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee47() {
+            return _regeneratorRuntime.wrap(function (_context47) {
+              while (1) switch (_context47.prev = _context47.next) {
+                case 0:
+                  _context47.next = 1;
+                  return Promise.resolve();
+                case 1:
+                case "end":
+                  return _context47.stop();
+              }
+            }, _callee47);
+          })));
+        case 1:
+          expect(chatMessagesState.loadMessages).toHaveBeenCalledWith({
+            force: true
+          });
+        case 2:
+        case "end":
+          return _context48.stop();
+      }
+    }, _callee48);
+  })));
+  it('rotates to a fresh session id when initial chat id clears', function () {
+    var _renderHook22 = renderHook(function (_ref52) {
+        var chatId = _ref52.chatId;
+        return useChatManager({
+          chatId: chatId,
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: wrapper,
+        initialProps: {
+          chatId: 'previous-session'
+        }
+      }),
+      rerender = _renderHook22.rerender;
+    rerender({
+      chatId: null
+    });
+    expect(getChatsStoreState().setActiveChatId).toHaveBeenCalledWith(null);
+  });
+  it('restores the message list when a retry stream fails on the active session', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee50() {
+    var dispatchSpy, _renderHook23, result;
+    return _regeneratorRuntime.wrap(function (_context50) {
+      while (1) switch (_context50.prev = _context50.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
+          }];
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          activeView.set('session-1');
+          _renderHook23 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook23.result;
+          _context50.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee49() {
+            return _regeneratorRuntime.wrap(function (_context49) {
+              while (1) switch (_context49.prev = _context49.next) {
+                case 0:
+                  _context49.next = 1;
+                  return result.current.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context49.stop();
+              }
+            }, _callee49);
+          })));
+        case 1:
+          replaceMessagesMock.mockClear();
+          act(function () {
+            var _streamCallbacks$onEr7, _streamCallbacks11;
+            (_streamCallbacks$onEr7 = (_streamCallbacks11 = streamCallbacks).onError) === null || _streamCallbacks$onEr7 === void 0 || _streamCallbacks$onEr7.call(_streamCallbacks11, {
+              sessionId: 'session-1',
+              messageId: 'retry-1',
+              placeholderId: 'answer-retry-1-streaming'
+            }, 'server_error');
+          });
+          expect(replaceMessagesMock).toHaveBeenCalledWith(chatMessagesState.messages);
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event',
+            detail: expect.objectContaining({
+              severity: 'error'
+            })
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context50.stop();
+      }
+    }, _callee50);
+  })));
+  it('commits assistant attachments when an active stream finishes', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee52() {
+    var attachment;
+    return _regeneratorRuntime.wrap(function (_context52) {
+      while (1) switch (_context52.prev = _context52.next) {
+        case 0:
+          activeView.set('session-1');
+          useSessionsStore.setState({
+            messages: {
+              'session-1': [{
+                id: streamingPlaceholderMessageId('live-attach'),
+                message: '',
+                role: ChatHistoryRole.ASSISTANT,
+                user: {
+                  id: 'assistant',
+                  name: 'MAIA'
+                },
+                date: new Date()
+              }]
+            }
+          });
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          });
+          attachment = {
+            id: 'att-1',
+            name: 'brief.pdf',
+            type: 'pdf',
+            size: 10,
+            file: new File([], 'brief.pdf')
+          };
+          _context52.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee51() {
+            var _streamCallbacks$onFi6, _streamCallbacks12;
+            return _regeneratorRuntime.wrap(function (_context51) {
+              while (1) switch (_context51.prev = _context51.next) {
+                case 0:
+                  _context51.next = 1;
+                  return (_streamCallbacks$onFi6 = (_streamCallbacks12 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi6 === void 0 ? void 0 : _streamCallbacks$onFi6.call(_streamCallbacks12, {
+                    sessionId: 'session-1',
+                    messageId: 'live-attach',
+                    placeholderId: streamingPlaceholderMessageId('live-attach')
+                  }, 'Respuesta con adjunto', [], 'memory-attach-1', [attachment], null, null);
+                case 1:
+                case "end":
+                  return _context51.stop();
+              }
+            }, _callee51);
+          })));
+        case 1:
+          expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+            id: 'answer-memory-attach-1',
+            attachments: expect.arrayContaining([expect.objectContaining({
+              id: 'att-1',
+              name: 'brief.pdf'
+            })])
+          }));
+        case 2:
+        case "end":
+          return _context52.stop();
+      }
+    }, _callee52);
+  })));
+  it('syncs task deletion on the project dashboard after approval', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee54() {
+    var deleteExistingTaskFromDashboard, originalPathname;
+    return _regeneratorRuntime.wrap(function (_context54) {
+      while (1) switch (_context54.prev = _context54.next) {
+        case 0:
+          deleteExistingTaskFromDashboard = jest.fn();
+          window.newProjectDashboard = {
+            deleteExistingTaskFromDashboard: deleteExistingTaskFromDashboard
+          };
+          originalPathname = window.location.pathname;
+          Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: _objectSpread(_objectSpread({}, window.location), {}, {
+              pathname: '/projects/42/tasks'
+            })
+          });
+          activeView.set('session-1');
+          chatMessagesState.messages = [{
+            id: 'approval-delete',
+            message: '¿Elimino la tarea?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approvalStatus: 'approved',
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'd1',
+                tool_name: 'delete_task',
+                tool_args: {
+                  task_id: 77
+                }
+              }]
+            }
+          }];
+          renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: function wrapper(_ref58) {
+              var children = _ref58.children;
+              return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+                value: {
+                  agent: testAgent,
+                  project: {
+                    id: 42,
+                    name: 'Alpha'
+                  }
+                },
+                children: children
+              });
+            }
+          });
+          _context54.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee53() {
+            var _streamCallbacks$onFi7, _streamCallbacks13;
+            return _regeneratorRuntime.wrap(function (_context53) {
+              while (1) switch (_context53.prev = _context53.next) {
+                case 0:
+                  _context53.next = 1;
+                  return (_streamCallbacks$onFi7 = (_streamCallbacks13 = streamCallbacks).onFinishStream) === null || _streamCallbacks$onFi7 === void 0 ? void 0 : _streamCallbacks$onFi7.call(_streamCallbacks13, {
+                    sessionId: 'session-1',
+                    messageId: 'delete-live',
+                    placeholderId: streamingPlaceholderMessageId('delete-live')
+                  }, 'Tarea eliminada', [], 'memory-delete-1');
+                case 1:
+                case "end":
+                  return _context53.stop();
+              }
+            }, _callee53);
+          })));
+        case 1:
+          expect(deleteExistingTaskFromDashboard).toHaveBeenCalledWith([77]);
+          Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: _objectSpread(_objectSpread({}, window.location), {}, {
+              pathname: originalPathname
+            })
+          });
+          delete window.newProjectDashboard;
+        case 2:
+        case "end":
+          return _context54.stop();
+      }
+    }, _callee54);
+  })));
+  it('commits a pending approval message on the active session', function () {
+    activeView.set('session-1');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onAp, _streamCallbacks14;
+      (_streamCallbacks$onAp = (_streamCallbacks14 = streamCallbacks).onApprovalRequired) === null || _streamCallbacks$onAp === void 0 || _streamCallbacks$onAp.call(_streamCallbacks14, {
+        sessionId: 'session-1',
+        messageId: 'live-hitl',
+        placeholderId: streamingPlaceholderMessageId('live-hitl')
+      }, {
+        type: 'approval_required',
+        session_id: 'session-1',
+        original_thread_id: 'orig-1',
+        pending_actions: [{
+          thread_id: 't1',
+          tool_name: 'edit_task',
+          tool_args: {
+            task_id: 1
+          },
+          tool_call_id: 'c1'
+        }],
+        total_actions: 1,
+        metadata: {}
+      }, '¿Confirmás la edición?');
+    });
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      approvalStatus: 'pending',
+      message: '¿Confirmás la edición?'
+    }));
+  });
+  it('does not paint approval UI when the stream was auto-approved', function () {
+    activeView.set('session-1');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onAp2, _streamCallbacks15;
+      (_streamCallbacks$onAp2 = (_streamCallbacks15 = streamCallbacks).onApprovalRequired) === null || _streamCallbacks$onAp2 === void 0 || _streamCallbacks$onAp2.call(_streamCallbacks15, {
+        sessionId: 'session-1',
+        messageId: 'auto-hitl',
+        placeholderId: streamingPlaceholderMessageId('auto-hitl')
+      }, {
+        type: 'approval_required',
+        session_id: 'session-1',
+        original_thread_id: 'orig-auto',
+        pending_actions: [{
+          thread_id: 't-auto',
+          tool_name: 'create_task',
+          tool_args: {},
+          tool_call_id: 'c-auto'
+        }],
+        total_actions: 1,
+        metadata: {},
+        auto_approved: true
+      }, 'Creando tarea');
+    });
+    expect(addMessageMock).not.toHaveBeenCalled();
+  });
+  it('marks background sessions unread when approval is required off-screen', function () {
+    activeView.set('session-visible');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-visible',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    act(function () {
+      var _streamCallbacks$onAp3, _streamCallbacks16;
+      (_streamCallbacks$onAp3 = (_streamCallbacks16 = streamCallbacks).onApprovalRequired) === null || _streamCallbacks$onAp3 === void 0 || _streamCallbacks$onAp3.call(_streamCallbacks16, {
+        sessionId: 'session-bg',
+        messageId: 'bg-hitl',
+        placeholderId: streamingPlaceholderMessageId('bg-hitl')
+      }, {
+        type: 'approval_required',
+        session_id: 'session-bg',
+        original_thread_id: 'orig-bg',
+        pending_actions: [{
+          thread_id: 't-bg',
+          tool_name: 'edit_task',
+          tool_args: {},
+          tool_call_id: 'c-bg'
+        }],
+        total_actions: 1,
+        metadata: {}
+      }, 'Aprobación pendiente');
+    });
+    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-bg');
+    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-bg', 'approval_required');
+    expect(addMessageMock).not.toHaveBeenCalled();
+  });
+  it('clears pinned context when switching to another existing chat', function () {
+    var setProject = jest.fn();
+    var setClient = jest.fn();
+    var setChipsProject = jest.fn();
+    var setTask = jest.fn();
+    var contextWrapper = function contextWrapper(_ref60) {
+      var children = _ref60.children;
+      return /*#__PURE__*/_jsx(GlobalContextTestProvider, {
+        value: {
+          agent: testAgent,
+          setProject: setProject,
+          setClient: setClient,
+          setChipsProject: setChipsProject,
+          setTask: setTask
+        },
+        children: children
+      });
+    };
+    var _renderHook24 = renderHook(function (_ref61) {
+        var chatId = _ref61.chatId;
+        return useChatManager({
+          chatId: chatId,
+          agents: [testAgent]
+        });
+      }, {
+        wrapper: contextWrapper,
+        initialProps: {
+          chatId: 'session-a'
+        }
+      }),
+      rerender = _renderHook24.rerender;
+    sessionStreamManager.isActive.mockReturnValue(true);
+    rerender({
+      chatId: 'session-b'
+    });
+    expect(setProject).toHaveBeenCalledWith(null);
+    expect(setClient).toHaveBeenCalledWith(null);
+    expect(setChipsProject).toHaveBeenCalledWith(null);
+    expect(setTask).toHaveBeenCalledWith(null);
+  });
+  it('commits partial assistant text when the stream stops mid-response', function () {
+    activeView.set('session-1');
+    renderHook(function () {
+      return useChatManager({
+        chatId: 'session-1',
+        agents: [testAgent]
+      });
+    }, {
+      wrapper: wrapper
+    });
+    var ctx = {
+      sessionId: 'session-1',
+      messageId: 'live-stop-1',
+      placeholderId: streamingPlaceholderMessageId('live-stop-1')
+    };
+    act(function () {
+      var _streamCallbacks$onSt2, _streamCallbacks17;
+      (_streamCallbacks$onSt2 = (_streamCallbacks17 = streamCallbacks).onStreamUpdate) === null || _streamCallbacks$onSt2 === void 0 || _streamCallbacks$onSt2.call(_streamCallbacks17, ctx, 'Parcial');
+    });
+    act(function () {
+      var _streamCallbacks$onSt3, _streamCallbacks18;
+      (_streamCallbacks$onSt3 = (_streamCallbacks18 = streamCallbacks).onStop) === null || _streamCallbacks$onSt3 === void 0 || _streamCallbacks$onSt3.call(_streamCallbacks18, 'Parcial');
+    });
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      message: 'Parcial',
+      role: ChatHistoryRole.ASSISTANT
+    }));
+    expect(addMessageMock).toHaveBeenCalledWith(expect.objectContaining({
+      role: ChatHistoryRole.ASSISTANT,
+      message: expect.stringMatching(/cancel/i)
+    }));
+  });
+  it('replays via orchestrator when retryCompletion reports turn_not_found', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee56() {
+    var _renderHook25, result;
+    return _regeneratorRuntime.wrap(function (_context56) {
+      while (1) switch (_context56.prev = _context56.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'question-retry',
+            message: '¿Status?',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date()
+          }, {
+            id: 'answer-turn-abc',
+            message: 'Error',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            isError: true,
+            memorySessionId: 'turn-abc'
+          }];
+          retryCompletionMock.mockResolvedValue({
+            started: false,
+            reason: 'turn_not_found'
+          });
+          _renderHook25 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook25.result;
+          _context56.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee55() {
+            return _regeneratorRuntime.wrap(function (_context55) {
+              while (1) switch (_context55.prev = _context55.next) {
+                case 0:
+                  _context55.next = 1;
+                  return result.current.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context55.stop();
+              }
+            }, _callee55);
+          })));
+        case 1:
+          expect(retryCompletionMock).toHaveBeenCalled();
+          expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({
+            message: '¿Status?'
+          }));
+        case 2:
+        case "end":
+          return _context56.stop();
+      }
+    }, _callee56);
+  })));
+  it('shows a snackbar when retryCompletion hits the concurrent stream limit', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee58() {
+    var dispatchSpy, _renderHook26, result;
+    return _regeneratorRuntime.wrap(function (_context58) {
+      while (1) switch (_context58.prev = _context58.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'question-limit',
+            message: 'Retry me',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date()
+          }, {
+            id: 'answer-turn-limit',
+            message: 'Error',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            isError: true,
+            memorySessionId: 'turn-limit'
+          }];
+          retryCompletionMock.mockResolvedValue({
+            started: false,
+            reason: 'limit'
+          });
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          _renderHook26 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook26.result;
+          _context58.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee57() {
+            return _regeneratorRuntime.wrap(function (_context57) {
+              while (1) switch (_context57.prev = _context57.next) {
+                case 0:
+                  _context57.next = 1;
+                  return result.current.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context57.stop();
+              }
+            }, _callee57);
+          })));
+        case 1:
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event',
+            detail: expect.objectContaining({
+              message: expect.any(String)
+            })
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context58.stop();
+      }
+    }, _callee58);
+  })));
+  it('shows a snackbar when replayViaOrchestrator hits the concurrent stream limit', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee60() {
+    var dispatchSpy, _renderHook27, result;
+    return _regeneratorRuntime.wrap(function (_context60) {
+      while (1) switch (_context60.prev = _context60.next) {
+        case 0:
+          chatMessagesState.messages = [{
+            id: 'question-replay-limit',
+            message: 'Hola',
+            role: ChatHistoryRole.USER,
+            user: {
+              id: '7',
+              name: 'Ana'
+            },
+            date: new Date()
+          }, {
+            id: 'answer-turn-replay-limit',
+            message: 'Error',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            isError: true,
+            memorySessionId: 'turn-replay-limit'
+          }];
+          retryCompletionMock.mockResolvedValue({
+            started: false,
+            reason: 'turn_not_found'
+          });
+          askMaiaMock.mockResolvedValue({
+            started: false,
+            reason: 'limit'
+          });
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          _renderHook27 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook27.result;
+          _context60.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee59() {
+            return _regeneratorRuntime.wrap(function (_context59) {
+              while (1) switch (_context59.prev = _context59.next) {
+                case 0:
+                  _context59.next = 1;
+                  return result.current.retryMessage(chatMessagesState.messages[1]);
+                case 1:
+                case "end":
+                  return _context59.stop();
+              }
+            }, _callee59);
+          })));
+        case 1:
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event'
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context60.stop();
+      }
+    }, _callee60);
+  })));
+  it('shows a snackbar when approval continue stream fails to start due to limit', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee62() {
+    var dispatchSpy, _renderHook28, result;
+    return _regeneratorRuntime.wrap(function (_context62) {
+      while (1) switch (_context62.prev = _context62.next) {
+        case 0:
+          activeView.set('session-1');
+          startContinueStreamMock.mockResolvedValue({
+            started: false,
+            reason: 'limit'
+          });
+          dispatchSpy = jest.spyOn(document, 'dispatchEvent');
+          chatMessagesState.messages = [{
+            id: 'msg-approval-limit',
+            message: 'Approve?',
+            role: ChatHistoryRole.ASSISTANT,
+            user: {
+              id: 'assistant',
+              name: 'MAIA'
+            },
+            date: new Date(),
+            approval: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 'thread-limit',
+                tool_name: 'edit_task',
+                tool_args: {}
+              }]
+            }
+          }];
+          _renderHook28 = renderHook(function () {
+            return useChatManager({
+              chatId: 'session-1',
+              agents: [testAgent]
+            });
+          }, {
+            wrapper: wrapper
+          }), result = _renderHook28.result;
+          _context62.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee61() {
+            return _regeneratorRuntime.wrap(function (_context61) {
+              while (1) switch (_context61.prev = _context61.next) {
+                case 0:
+                  _context61.next = 1;
+                  return result.current.handleApprovalDecision(['thread-limit'], 'approve');
+                case 1:
+                case "end":
+                  return _context61.stop();
+              }
+            }, _callee61);
+          })));
+        case 1:
+          expect(startContinueStreamMock).toHaveBeenCalled();
+          expect(dispatchSpy).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'snackbar-event'
+          }));
+          dispatchSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context62.stop();
+      }
+    }, _callee62);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","GlobalContextTestProvider","testAgent","useSessionsStore","sessionStreamManager","ChatHistoryRole","Feedback","maia","activeView","useOrchestratorStream","getChatsStoreState","notifySessionFinishedInBackground","fetchAgentDetail","MAIA_HOURS_CHARGED_EVENT","streamingPlaceholderMessageId","useMultipleChoiceStore","useChatManager","jsx","_jsx","fetchAgentDetailMock","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","ensureSessionNotificationsInitialized","isActive","getActiveCount","startStream","startContinueStream","apply","arguments","stopStream","MAX_CONCURRENT_STREAMS","wrapper","_ref","children","value","agent","describe","beforeEach","clearAllMocks","mockImplementation","options","onError","onStreamUpdate","onStop","onApprovalRequired","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","_renderHook3","_context4","pending","messageId","question","answer","dismissedMessageIds","answerPending","key","_callee3","_context3","toHaveBeenLastCalledWith","multipleChoiceAnswer","toBeNull","_callee6","dispatchSpy","_renderHook4","_context6","spyOn","document","_callee5","_context5","not","toHaveBeenCalled","type","mockRestore","_renderHook5","stopGeneration","_renderHook6","resetChat","currentChatId","_callee8","_renderHook7","_context8","_callee7","_context7","_callee0","_renderHook8","_context0","_callee9","_context9","mentions","label","contextMessage","user","arrayContaining","_callee10","_renderHook9","_context10","USER","date","Date","ASSISTANT","isFrontendCancelled","_callee1","_context1","retryMessage","_callee12","setProject","project","_renderHook0","_context12","_ref13","_callee11","_context11","mockClear","changeProject","feeId","clientId","projectId","_renderHook1","_callee14","_renderHook10","_context14","approval","session_id","pending_actions","thread_id","tool_name","tool_args","task_id","_callee13","_context13","handleApprovalDecision","continueRequest","decision","_callee16","_renderHook11","_context16","_callee15","_context15","sessionId","threadIds","_callee18","_renderHook12","_context18","mocked","_callee17","_context17","handleFeedback","THUMBS_UP","_callee20","_renderHook13","_context20","_callee19","_context19","THUMBS_DOWN","toHaveProperty","_callee22","consoleSpy","_renderHook14","_context22","console","undefined","_callee21","_context21","_callee24","attachment","_renderHook15","_context24","size","file","File","_callee23","_context23","attachments","_callee26","_renderHook16","_context26","_callee25","_context25","initializeChat","_callee28","_renderHook17","_context28","userInitialMessage","faqId","_callee27","_context27","_callee30","_renderHook18","_context30","_callee29","_context29","_callee32","_renderHook19","_context32","_callee31","_context31","_callee34","_renderHook20","_context34","_callee33","_context33","_callee36","editedActions","_renderHook21","_context36","args","_callee35","_context35","_streamCallbacks$onEr","_streamCallbacks","call","placeholderId","isError","suggestions","_streamCallbacks$onEr2","_streamCallbacks2","_streamCallbacks$onEr3","_streamCallbacks3","_streamCallbacks$onEr4","_streamCallbacks4","ctx","_streamCallbacks$onSt","_streamCallbacks5","getMessages","_callee38","_context38","_callee37","_streamCallbacks$onFi","_streamCallbacks6","_context37","_streamCallbacks$onEr5","_streamCallbacks7","stringContaining","_streamCallbacks$onEr6","_streamCallbacks8","_callee40","addExistingTaskToDashboard","originalPathname","taskUrl","_context40","window","newProjectDashboard","location","pathname","defineProperty","configurable","_objectSpread","approvalStatus","_ref42","_callee39","_streamCallbacks$onFi2","_streamCallbacks9","_context39","_callee42","onHoursCharged","event","_context42","addEventListener","_callee41","_streamCallbacks$onFi3","_streamCallbacks0","_context41","calls","detail","tools","removeEventListener","_callee44","onMergeAgent","_context44","MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS","_callee43","_streamCallbacks$onFi4","_streamCallbacks1","_context43","Promise","resolve","_callee46","refetchTask","_context46","taskPanel","taskId","_callee45","_streamCallbacks$onFi5","_streamCallbacks10","_context45","_callee48","_context48","status","finishedAt","_callee47","_context47","force","_renderHook22","_ref52","initialProps","rerender","_callee50","_renderHook23","_context50","_callee49","_context49","_streamCallbacks$onEr7","_streamCallbacks11","severity","_callee52","_context52","_callee51","_streamCallbacks$onFi6","_streamCallbacks12","_context51","_callee54","deleteExistingTaskFromDashboard","_context54","_ref58","_callee53","_streamCallbacks$onFi7","_streamCallbacks13","_context53","_streamCallbacks$onAp","_streamCallbacks14","original_thread_id","tool_call_id","total_actions","metadata","_streamCallbacks$onAp2","_streamCallbacks15","auto_approved","_streamCallbacks$onAp3","_streamCallbacks16","setClient","setChipsProject","setTask","contextWrapper","_ref60","_renderHook24","_ref61","_streamCallbacks$onSt2","_streamCallbacks17","_streamCallbacks$onSt3","_streamCallbacks18","stringMatching","_callee56","_renderHook25","_context56","memorySessionId","reason","_callee55","_context55","_callee58","_renderHook26","_context58","_callee57","_context57","any","String","_callee60","_renderHook27","_context60","_callee59","_context59","_callee62","_renderHook28","_context62","_callee61","_context61"],"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 { ApprovalRequest, 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 { fetchAgentDetail } from '../../services/maia/Agents/fetchAgentDetail'\nimport { MAIA_HOURS_CHARGED_EVENT } from '../../constants/plannerSyncEvents'\nimport { streamingPlaceholderMessageId } from '../../utils/streamActivityMessages'\nimport { useMultipleChoiceStore } from '../../store/useMultipleChoiceStore'\nimport { useChatManager } from './useChatManager'\n\nconst fetchAgentDetailMock = fetchAgentDetail as jest.MockedFunction<typeof fetchAgentDetail>\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  onStop?: (partialText: string) => void\n  onApprovalRequired?: (ctx: StreamContext, approval: ApprovalRequest, 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        onStop: options.onStop,\n        onApprovalRequired: options.onApprovalRequired,\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('marks the message that answers a multiple-choice card and consumes the answer', async () => {\n    useMultipleChoiceStore.setState({\n      pending: { messageId: 'a1', question: null, options: [] },\n      answer: null,\n      dismissedMessageIds: {},\n    })\n    useMultipleChoiceStore.getState().answerPending({ key: 'B' })\n    const { result } = renderHook(() => useChatManager({ chatId: 'session-1', agents: [testAgent] }), { wrapper })\n\n    await act(async () => {\n      await result.current.sendMessage('Proyecto Beta')\n    })\n    expect(askMaiaMock).toHaveBeenLastCalledWith(expect.objectContaining({ multipleChoiceAnswer: { key: 'B' } }))\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({ message: 'Proyecto Beta', multipleChoiceAnswer: { key: 'B' } })\n    )\n\n    expect(useMultipleChoiceStore.getState().answer).toBeNull()\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('maps prompt-too-long stream errors without retry suggestions', () => {\n    activeView.set('session-1')\n\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-long',\n          placeholderId: 'answer-msg-long-streaming',\n        },\n        'invalid_request_error',\n        'prompt is too long: 12000 tokens'\n      )\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        isError: true,\n        message: 'chat.errorPromptTooLong',\n      })\n    )\n    expect(addMessageMock).not.toHaveBeenCalledWith(\n      expect.objectContaining({\n        suggestions: ['chat.retry'],\n      })\n    )\n  })\n\n  it('marks background sessions unread when a stream errors off-screen', () => {\n    activeView.set('session-visible')\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-visible',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onError?.(\n        {\n          sessionId: 'session-bg',\n          messageId: 'bg-err',\n          placeholderId: 'answer-bg-err-streaming',\n        },\n        'server_error'\n      )\n    })\n\n    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-bg')\n    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-bg', 'error')\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  it('commits prompt-too-long 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-long',\n          placeholderId: 'answer-msg-long-streaming',\n        },\n        'invalid_request_error',\n        'prompt is too long: 12000 tokens'\n      )\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        isError: true,\n        message: expect.stringContaining('chat.errorPromptTooLong'),\n      })\n    )\n    expect(addMessageMock).not.toHaveBeenCalledWith(\n      expect.objectContaining({\n        suggestions: ['chat.retry'],\n      })\n    )\n  })\n\n  it('marks background sessions unread when a stream errors off-screen', () => {\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    activeView.set('other-session')\n\n    act(() => {\n      streamCallbacks.onError?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'bg-err',\n          placeholderId: 'answer-bg-err-streaming',\n        },\n        'server_error'\n      )\n    })\n\n    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-1')\n    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-1', 'error')\n  })\n\n  it('syncs task creation with the project dashboard when approval completes on the active session', async () => {\n    const addExistingTaskToDashboard = jest.fn()\n    window.newProjectDashboard = { addExistingTaskToDashboard }\n    const originalPathname = window.location.pathname\n    Object.defineProperty(window, 'location', {\n      configurable: true,\n      value: { ...window.location, pathname: '/projects/42/tasks' },\n    })\n\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'user-1',\n        message: 'Crea la tarea',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n        projectId: 42,\n      },\n      {\n        id: 'approval-msg',\n        message: '¿Confirmás?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approvalStatus: 'approved',\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 't1', tool_name: 'create_task', tool_args: { task_id: 55 } }],\n        },\n      },\n    ]\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      {\n        wrapper: ({ children }) => (\n          <GlobalContextTestProvider value={{ agent: testAgent, project: { id: 42, name: 'Alpha' } as never }}>\n            {children}\n          </GlobalContextTestProvider>\n        ),\n      }\n    )\n\n    const taskUrl = 'https://app.cor.com/tasks/55/detail'\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'live-1',\n          placeholderId: streamingPlaceholderMessageId('live-1'),\n        },\n        taskUrl,\n        [],\n        'memory-task-1',\n        null,\n        ['Seguir'],\n        null\n      )\n    })\n\n    expect(addExistingTaskToDashboard).toHaveBeenCalledWith([55])\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        id: 'answer-memory-task-1',\n        suggestions: ['Seguir'],\n      })\n    )\n\n    Object.defineProperty(window, 'location', {\n      configurable: true,\n      value: { ...window.location, pathname: originalPathname },\n    })\n    delete window.newProjectDashboard\n  })\n\n  it('dispatches planner sync when hours charge approval completes', async () => {\n    const onHoursCharged = jest.fn()\n    window.addEventListener(MAIA_HOURS_CHARGED_EVENT, onHoursCharged)\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'approval-hours',\n        message: '¿Cargo horas?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approvalStatus: 'approved',\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'h1', tool_name: 'create_hours', tool_args: {} }],\n        },\n      },\n    ]\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'hours-1',\n          placeholderId: streamingPlaceholderMessageId('hours-1'),\n        },\n        'Horas cargadas',\n        [],\n        'memory-hours-1'\n      )\n    })\n\n    expect(onHoursCharged).toHaveBeenCalled()\n    const event = onHoursCharged.mock.calls[0][0] as CustomEvent\n    expect(event.detail.tools).toEqual(['create_hours'])\n\n    window.removeEventListener(MAIA_HOURS_CHARGED_EVENT, onHoursCharged)\n  })\n\n  it('fetches and merges a newly created agent after stream finish', async () => {\n    window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = true\n    fetchAgentDetailMock.mockResolvedValue({ id: 'agent-new', name: 'Nuevo' } as never)\n    const onMergeAgent = jest.fn()\n    document.addEventListener('maia-merge-created-agent-into-list', onMergeAgent)\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'approval-agent',\n        message: '¿Creo el agente?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approvalStatus: 'approved',\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'a1', tool_name: 'create_agent', tool_args: {} }],\n        },\n      },\n    ]\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'agent-live',\n          placeholderId: streamingPlaceholderMessageId('agent-live'),\n        },\n        'Agente creado',\n        [],\n        'memory-agent-1',\n        null,\n        null,\n        'agent-new'\n      )\n      await Promise.resolve()\n    })\n\n    expect(fetchAgentDetailMock).toHaveBeenCalledWith('agent-new')\n    expect(onMergeAgent).toHaveBeenCalled()\n    document.removeEventListener('maia-merge-created-agent-into-list', onMergeAgent)\n    window.MAIA_CHAT_AI_FEATURE_ACCESS_MULTI_AGENTS = false\n  })\n\n  it('refetches the open task panel after an approved task edit', async () => {\n    const refetchTask = jest.fn()\n    window.taskPanel = { taskId: 88, refetchTask }\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'approval-edit',\n        message: '¿Edito?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approvalStatus: 'approved',\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'e1', tool_name: 'edit_task', tool_args: { task_id: 88 } }],\n        },\n      },\n    ]\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'edit-live',\n          placeholderId: streamingPlaceholderMessageId('edit-live'),\n        },\n        'Tarea actualizada',\n        [],\n        'memory-edit-1'\n      )\n    })\n\n    expect(refetchTask).toHaveBeenCalled()\n    delete window.taskPanel\n  })\n\n  it('reloads messages when the active session ends with a stale streaming placeholder', async () => {\n    useSessionsStore.setState({\n      meta: { 'session-1': { status: 'complete', finishedAt: '2024-06-01T00:00:00.000Z' } },\n      messages: {\n        'session-1': [\n          {\n            id: streamingPlaceholderMessageId('stale'),\n            message: '',\n            role: ChatHistoryRole.ASSISTANT,\n            user: { id: 'assistant', name: 'MAIA' },\n            date: new Date(),\n          },\n        ],\n      },\n    })\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    await act(async () => {\n      await Promise.resolve()\n    })\n\n    expect(chatMessagesState.loadMessages).toHaveBeenCalledWith({ force: true })\n  })\n\n  it('rotates to a fresh session id when initial chat id clears', () => {\n    const { rerender } = renderHook(\n      ({ chatId }: { chatId: string | null }) =>\n        useChatManager({\n          chatId,\n          agents: [testAgent],\n        }),\n      {\n        wrapper,\n        initialProps: { chatId: 'previous-session' as string | null },\n      }\n    )\n\n    rerender({ chatId: null })\n\n    expect(getChatsStoreState().setActiveChatId).toHaveBeenCalledWith(null)\n  })\n\n  it('restores the message list when a retry stream fails on the active session', 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    const dispatchSpy = jest.spyOn(document, 'dispatchEvent')\n    activeView.set('session-1')\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    replaceMessagesMock.mockClear()\n\n    act(() => {\n      streamCallbacks.onError?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'retry-1',\n          placeholderId: 'answer-retry-1-streaming',\n        },\n        'server_error'\n      )\n    })\n\n    expect(replaceMessagesMock).toHaveBeenCalledWith(chatMessagesState.messages)\n    expect(dispatchSpy).toHaveBeenCalledWith(\n      expect.objectContaining({\n        type: 'snackbar-event',\n        detail: expect.objectContaining({ severity: 'error' }),\n      })\n    )\n\n    dispatchSpy.mockRestore()\n  })\n\n  it('commits assistant attachments when an active stream finishes', async () => {\n    activeView.set('session-1')\n    useSessionsStore.setState({\n      messages: {\n        'session-1': [\n          {\n            id: streamingPlaceholderMessageId('live-attach'),\n            message: '',\n            role: ChatHistoryRole.ASSISTANT,\n            user: { id: 'assistant', name: 'MAIA' },\n            date: new Date(),\n          },\n        ],\n      },\n    })\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    const attachment = {\n      id: 'att-1',\n      name: 'brief.pdf',\n      type: 'pdf',\n      size: 10,\n      file: new File([], 'brief.pdf'),\n    }\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'live-attach',\n          placeholderId: streamingPlaceholderMessageId('live-attach'),\n        },\n        'Respuesta con adjunto',\n        [],\n        'memory-attach-1',\n        [attachment],\n        null,\n        null\n      )\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        id: 'answer-memory-attach-1',\n        attachments: expect.arrayContaining([expect.objectContaining({ id: 'att-1', name: 'brief.pdf' })]),\n      })\n    )\n  })\n\n  it('syncs task deletion on the project dashboard after approval', async () => {\n    const deleteExistingTaskFromDashboard = jest.fn()\n    window.newProjectDashboard = { deleteExistingTaskFromDashboard }\n    const originalPathname = window.location.pathname\n    Object.defineProperty(window, 'location', {\n      configurable: true,\n      value: { ...window.location, pathname: '/projects/42/tasks' },\n    })\n\n    activeView.set('session-1')\n    chatMessagesState.messages = [\n      {\n        id: 'approval-delete',\n        message: '¿Elimino la tarea?',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        approvalStatus: 'approved',\n        approval: {\n          session_id: 'session-1',\n          pending_actions: [{ thread_id: 'd1', tool_name: 'delete_task', tool_args: { task_id: 77 } }],\n        },\n      },\n    ]\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      {\n        wrapper: ({ children }) => (\n          <GlobalContextTestProvider value={{ agent: testAgent, project: { id: 42, name: 'Alpha' } as never }}>\n            {children}\n          </GlobalContextTestProvider>\n        ),\n      }\n    )\n\n    await act(async () => {\n      await streamCallbacks.onFinishStream?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'delete-live',\n          placeholderId: streamingPlaceholderMessageId('delete-live'),\n        },\n        'Tarea eliminada',\n        [],\n        'memory-delete-1'\n      )\n    })\n\n    expect(deleteExistingTaskFromDashboard).toHaveBeenCalledWith([77])\n\n    Object.defineProperty(window, 'location', {\n      configurable: true,\n      value: { ...window.location, pathname: originalPathname },\n    })\n    delete window.newProjectDashboard\n  })\n\n  it('commits a pending approval message on the active session', () => {\n    activeView.set('session-1')\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onApprovalRequired?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'live-hitl',\n          placeholderId: streamingPlaceholderMessageId('live-hitl'),\n        },\n        {\n          type: 'approval_required',\n          session_id: 'session-1',\n          original_thread_id: 'orig-1',\n          pending_actions: [{ thread_id: 't1', tool_name: 'edit_task', tool_args: { task_id: 1 }, tool_call_id: 'c1' }],\n          total_actions: 1,\n          metadata: {},\n        },\n        '¿Confirmás la edición?'\n      )\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({\n        approvalStatus: 'pending',\n        message: '¿Confirmás la edición?',\n      })\n    )\n  })\n\n  it('does not paint approval UI when the stream was auto-approved', () => {\n    activeView.set('session-1')\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-1',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onApprovalRequired?.(\n        {\n          sessionId: 'session-1',\n          messageId: 'auto-hitl',\n          placeholderId: streamingPlaceholderMessageId('auto-hitl'),\n        },\n        {\n          type: 'approval_required',\n          session_id: 'session-1',\n          original_thread_id: 'orig-auto',\n          pending_actions: [{ thread_id: 't-auto', tool_name: 'create_task', tool_args: {}, tool_call_id: 'c-auto' }],\n          total_actions: 1,\n          metadata: {},\n          auto_approved: true,\n        },\n        'Creando tarea'\n      )\n    })\n\n    expect(addMessageMock).not.toHaveBeenCalled()\n  })\n\n  it('marks background sessions unread when approval is required off-screen', () => {\n    activeView.set('session-visible')\n\n    renderHook(\n      () =>\n        useChatManager({\n          chatId: 'session-visible',\n          agents: [testAgent],\n        }),\n      { wrapper }\n    )\n\n    act(() => {\n      streamCallbacks.onApprovalRequired?.(\n        {\n          sessionId: 'session-bg',\n          messageId: 'bg-hitl',\n          placeholderId: streamingPlaceholderMessageId('bg-hitl'),\n        },\n        {\n          type: 'approval_required',\n          session_id: 'session-bg',\n          original_thread_id: 'orig-bg',\n          pending_actions: [{ thread_id: 't-bg', tool_name: 'edit_task', tool_args: {}, tool_call_id: 'c-bg' }],\n          total_actions: 1,\n          metadata: {},\n        },\n        'Aprobación pendiente'\n      )\n    })\n\n    expect(getChatsStoreState().markChatAsUnread).toHaveBeenCalledWith('session-bg')\n    expect(notifySessionFinishedInBackground).toHaveBeenCalledWith('session-bg', 'approval_required')\n    expect(addMessageMock).not.toHaveBeenCalled()\n  })\n\n  it('clears pinned context when switching to another existing chat', () => {\n    const setProject = jest.fn()\n    const setClient = jest.fn()\n    const setChipsProject = jest.fn()\n    const setTask = jest.fn()\n\n    const contextWrapper = ({ children }: { children: ReactNode }) => (\n      <GlobalContextTestProvider\n        value={{\n          agent: testAgent,\n          setProject,\n          setClient,\n          setChipsProject,\n          setTask,\n        }}\n      >\n        {children}\n      </GlobalContextTestProvider>\n    )\n\n    const { rerender } = renderHook(\n      ({ chatId }: { chatId: string | null }) =>\n        useChatManager({\n          chatId,\n          agents: [testAgent],\n        }),\n      {\n        wrapper: contextWrapper,\n        initialProps: { chatId: 'session-a' as string | null },\n      }\n    )\n\n    ;(sessionStreamManager.isActive as jest.Mock).mockReturnValue(true)\n    rerender({ chatId: 'session-b' })\n\n    expect(setProject).toHaveBeenCalledWith(null)\n    expect(setClient).toHaveBeenCalledWith(null)\n    expect(setChipsProject).toHaveBeenCalledWith(null)\n    expect(setTask).toHaveBeenCalledWith(null)\n  })\n\n  it('commits partial assistant text when the stream stops mid-response', () => {\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-stop-1',\n      placeholderId: streamingPlaceholderMessageId('live-stop-1'),\n    }\n\n    act(() => {\n      streamCallbacks.onStreamUpdate?.(ctx, 'Parcial')\n    })\n\n    act(() => {\n      streamCallbacks.onStop?.('Parcial')\n    })\n\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({ message: 'Parcial', role: ChatHistoryRole.ASSISTANT })\n    )\n    expect(addMessageMock).toHaveBeenCalledWith(\n      expect.objectContaining({ role: ChatHistoryRole.ASSISTANT, message: expect.stringMatching(/cancel/i) })\n    )\n  })\n\n  it('replays via orchestrator when retryCompletion reports turn_not_found', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'question-retry',\n        message: '¿Status?',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n      },\n      {\n        id: 'answer-turn-abc',\n        message: 'Error',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        isError: true,\n        memorySessionId: 'turn-abc',\n      },\n    ]\n    retryCompletionMock.mockResolvedValue({ started: false, reason: 'turn_not_found' })\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(retryCompletionMock).toHaveBeenCalled()\n    expect(askMaiaMock).toHaveBeenCalledWith(expect.objectContaining({ message: '¿Status?' }))\n  })\n\n  it('shows a snackbar when retryCompletion hits the concurrent stream limit', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'question-limit',\n        message: 'Retry me',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n      },\n      {\n        id: 'answer-turn-limit',\n        message: 'Error',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        isError: true,\n        memorySessionId: 'turn-limit',\n      },\n    ]\n    retryCompletionMock.mockResolvedValue({ started: false, reason: 'limit' })\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.retryMessage(chatMessagesState.messages[1])\n    })\n\n    expect(dispatchSpy).toHaveBeenCalledWith(\n      expect.objectContaining({\n        type: 'snackbar-event',\n        detail: expect.objectContaining({ message: expect.any(String) }),\n      })\n    )\n    dispatchSpy.mockRestore()\n  })\n\n  it('shows a snackbar when replayViaOrchestrator hits the concurrent stream limit', async () => {\n    chatMessagesState.messages = [\n      {\n        id: 'question-replay-limit',\n        message: 'Hola',\n        role: ChatHistoryRole.USER,\n        user: { id: '7', name: 'Ana' },\n        date: new Date(),\n      },\n      {\n        id: 'answer-turn-replay-limit',\n        message: 'Error',\n        role: ChatHistoryRole.ASSISTANT,\n        user: { id: 'assistant', name: 'MAIA' },\n        date: new Date(),\n        isError: true,\n        memorySessionId: 'turn-replay-limit',\n      },\n    ]\n    retryCompletionMock.mockResolvedValue({ started: false, reason: 'turn_not_found' })\n    askMaiaMock.mockResolvedValue({ started: false, reason: 'limit' })\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.retryMessage(chatMessagesState.messages[1])\n    })\n\n    expect(dispatchSpy).toHaveBeenCalledWith(\n      expect.objectContaining({\n        type: 'snackbar-event',\n      })\n    )\n    dispatchSpy.mockRestore()\n  })\n\n  it('shows a snackbar when approval continue stream fails to start due to limit', async () => {\n    activeView.set('session-1')\n    startContinueStreamMock.mockResolvedValue({ started: false, reason: 'limit' })\n    const dispatchSpy = jest.spyOn(document, 'dispatchEvent')\n    chatMessagesState.messages = [\n      {\n        id: 'msg-approval-limit',\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-limit', 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-limit'], 'approve')\n    })\n\n    expect(startContinueStreamMock).toHaveBeenCalled()\n    expect(dispatchSpy).toHaveBeenCalledWith(\n      expect.objectContaining({\n        type: 'snackbar-event',\n      })\n    )\n    dispatchSpy.mockRestore()\n  })\n})\n"],"mappings":"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","ignoreList":[]}