@projectcor/maia-components 2.49.0 → 2.49.1-1

package/lib/store/sessions/sessionStreamManager.spec.js

@@ -0,0 +1,939 @@
+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 maia from '../../services/maia';
+import { createHangingSseResponse, createJsonResponse, createSseResponse } from '../../test/mockSseStream';
+import { sessionStreamingText } from './sessionStreamingText';
+import { MAX_CONCURRENT_STREAMS, sessionStreamManager } from './sessionStreamManager';
+import { useSessionsStore } from './useSessionsStore';
+jest.mock('../../services/maia', function () {
+  return {
+    __esModule: true,
+    "default": {
+      Orchestrator: {
+        orchestrator: jest.fn(),
+        continueThread: jest.fn(),
+        retryCompletion: jest.fn()
+      }
+    }
+  };
+});
+jest.mock('./sessionNotifications', function () {
+  return {
+    ensureSessionNotificationsInitialized: jest.fn()
+  };
+});
+var orchestratorMock = maia.Orchestrator.orchestrator;
+var continueThreadMock = maia.Orchestrator.continueThread;
+var retryCompletionMock = maia.Orchestrator.retryCompletion;
+var t = function t(key) {
+  return key;
+};
+var baseStartParams = {
+  sessionId: 'session-1',
+  placeholderId: 'placeholder-1',
+  request: {
+    message: 'hola'
+  },
+  callbacks: {},
+  t: t
+};
+var resetState = function resetState() {
+  sessionStreamManager.abortAll();
+  sessionStreamingText.clearAll();
+  useSessionsStore.setState({
+    meta: {},
+    messages: {},
+    viewCache: {}
+  });
+  jest.clearAllMocks();
+};
+describe('sessionStreamManager', function () {
+  beforeEach(function () {
+    resetState();
+    jest.useFakeTimers();
+  });
+  afterEach(function () {
+    sessionStreamManager.abortAll();
+    jest.useRealTimers();
+  });
+  it('exposes MAX_CONCURRENT_STREAMS as 4', function () {
+    expect(MAX_CONCURRENT_STREAMS).toBe(4);
+  });
+  it('returns already_active when the session is already streaming', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var second;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          orchestratorMock.mockResolvedValue(createHangingSseResponse());
+          sessionStreamManager.startStream(baseStartParams)["catch"](function () {
+            return undefined;
+          });
+          _context.next = 1;
+          return Promise.resolve();
+        case 1:
+          _context.next = 2;
+          return sessionStreamManager.startStream(baseStartParams);
+        case 2:
+          second = _context.sent;
+          expect(second).toEqual({
+            started: false,
+            reason: 'already_active'
+          });
+          expect(sessionStreamManager.isActive('session-1')).toBe(true);
+          sessionStreamManager.stopStream('session-1');
+        case 3:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('returns limit when concurrent streams reach the cap', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var blocked;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          orchestratorMock.mockResolvedValue(createHangingSseResponse());
+          ['s1', 's2', 's3', 's4'].forEach(function (sessionId) {
+            sessionStreamManager.startStream(_objectSpread(_objectSpread({}, baseStartParams), {}, {
+              sessionId: sessionId,
+              placeholderId: "ph-".concat(sessionId)
+            }))["catch"](function () {
+              return undefined;
+            });
+          });
+          _context2.next = 1;
+          return Promise.resolve();
+        case 1:
+          expect(sessionStreamManager.getActiveCount()).toBe(4);
+          _context2.next = 2;
+          return sessionStreamManager.startStream(_objectSpread(_objectSpread({}, baseStartParams), {}, {
+            sessionId: 's5',
+            placeholderId: 'ph-s5'
+          }));
+        case 2:
+          blocked = _context2.sent;
+          expect(blocked).toEqual({
+            started: false,
+            reason: 'limit'
+          });
+          sessionStreamManager.abortAll();
+        case 3:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('streams tokens and completes with store + callbacks updated', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var onStartWriting, onStreamUpdate, onFinishStream, result;
+    return _regeneratorRuntime.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          onStartWriting = jest.fn();
+          onStreamUpdate = jest.fn();
+          onFinishStream = jest.fn();
+          orchestratorMock.mockResolvedValue(createSseResponse([{
+            event: 'token',
+            data: {
+              content: 'Hola'
+            }
+          }, {
+            event: 'token',
+            data: {
+              content: ' mundo'
+            }
+          }, {
+            event: 'complete',
+            data: {
+              content: 'Hola mundo',
+              memory_session_id: 'mem-1',
+              suggest_reply: ['¿Algo más?']
+            }
+          }]));
+          _context3.next = 1;
+          return sessionStreamManager.startStream(_objectSpread(_objectSpread({}, baseStartParams), {}, {
+            callbacks: {
+              onStartWriting: onStartWriting,
+              onStreamUpdate: onStreamUpdate,
+              onFinishStream: onFinishStream
+            }
+          }));
+        case 1:
+          result = _context3.sent;
+          jest.runAllTimers();
+          expect(result).toEqual({
+            started: true
+          });
+          expect(onStartWriting).toHaveBeenCalled();
+          expect(onStreamUpdate).toHaveBeenCalledWith('Hola mundo');
+          expect(onFinishStream).toHaveBeenCalledWith(expect.objectContaining({
+            content: 'Hola mundo',
+            memorySessionId: 'mem-1',
+            suggestions: ['¿Algo más?']
+          }));
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'complete',
+            isLoading: false,
+            isWriting: false
+          });
+          expect(sessionStreamManager.isActive('session-1')).toBe(false);
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('maps SSE error events to session error state', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var onError;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          onError = jest.fn();
+          orchestratorMock.mockResolvedValue(createSseResponse([{
+            event: 'error',
+            data: {
+              error: {
+                type: 'rate_limit',
+                message: 'Too many requests'
+              }
+            }
+          }]));
+          _context4.next = 1;
+          return sessionStreamManager.startStream(_objectSpread(_objectSpread({}, baseStartParams), {}, {
+            callbacks: {
+              onError: onError
+            }
+          }));
+        case 1:
+          jest.runAllTimers();
+          expect(onError).toHaveBeenCalledWith('rate_limit', 'Too many requests');
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'error',
+            isLoading: false,
+            isWriting: false,
+            error: {
+              type: 'rate_limit',
+              message: 'Too many requests'
+            }
+          });
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('requires approval and clears live text when not pre-approved', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+    var onApprovalRequired;
+    return _regeneratorRuntime.wrap(function (_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          onApprovalRequired = jest.fn();
+          orchestratorMock.mockResolvedValue(createSseResponse([{
+            event: 'token',
+            data: {
+              content: 'Parcial'
+            }
+          }, {
+            event: 'approval_required',
+            data: {
+              session_id: 'session-1',
+              pending_actions: [{
+                thread_id: 't1',
+                tool_name: 'create_task'
+              }]
+            }
+          }]));
+          _context5.next = 1;
+          return sessionStreamManager.startStream(_objectSpread(_objectSpread({}, baseStartParams), {}, {
+            callbacks: {
+              onApprovalRequired: onApprovalRequired
+            }
+          }));
+        case 1:
+          jest.runAllTimers();
+          expect(onApprovalRequired).toHaveBeenCalledWith(expect.objectContaining({
+            session_id: 'session-1'
+          }), 'Parcial');
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'awaiting_approval',
+            isWriting: false
+          });
+          expect(sessionStreamingText.getSnapshot('session-1').text).toBe('');
+        case 2:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  })));
+  it('stopStream aborts the stream and marks the session as cancelled', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+    var onStop;
+    return _regeneratorRuntime.wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          onStop = jest.fn();
+          orchestratorMock.mockResolvedValue(createHangingSseResponse());
+          sessionStreamManager.startStream(_objectSpread(_objectSpread({}, baseStartParams), {}, {
+            callbacks: {
+              onStop: onStop
+            }
+          }))["catch"](function () {
+            return undefined;
+          });
+          _context6.next = 1;
+          return Promise.resolve();
+        case 1:
+          sessionStreamingText.setText('session-1', 'placeholder-1', 'Texto parcial');
+          sessionStreamManager.stopStream('session-1', {
+            onStop: onStop
+          });
+          expect(onStop).toHaveBeenCalledWith('Texto parcial');
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'cancelled',
+            isLoading: false,
+            isWriting: false
+          });
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  it('startContinueStream rejects non-ok responses', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+    var onError, result;
+    return _regeneratorRuntime.wrap(function (_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          onError = jest.fn();
+          continueThreadMock.mockResolvedValue(createJsonResponse({
+            detail: 'fail'
+          }, 500));
+          _context7.next = 1;
+          return sessionStreamManager.startContinueStream({
+            sessionId: 'session-1',
+            placeholderId: 'placeholder-1',
+            continueRequest: {
+              thread_ids: ['t1'],
+              session_id: 'session-1',
+              decision: 'approve'
+            },
+            callbacks: {
+              onError: onError
+            },
+            t: t
+          });
+        case 1:
+          result = _context7.sent;
+          expect(result).toEqual({
+            started: true
+          });
+          expect(onError).toHaveBeenCalled();
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'error'
+          });
+        case 2:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  })));
+  it('startRetryStream returns turn_not_found on 404', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+    var result;
+    return _regeneratorRuntime.wrap(function (_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          retryCompletionMock.mockResolvedValue(createJsonResponse({
+            detail: 'Turn not found'
+          }, 404));
+          _context8.next = 1;
+          return sessionStreamManager.startRetryStream({
+            sessionId: 'session-1',
+            placeholderId: 'placeholder-1',
+            retryRequest: {
+              session_id: 'session-1',
+              turn_id: 'missing'
+            },
+            callbacks: {},
+            t: t
+          });
+        case 1:
+          result = _context8.sent;
+          expect(result).toEqual({
+            started: false,
+            reason: 'turn_not_found'
+          });
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'idle',
+            isLoading: false,
+            isWriting: false
+          });
+        case 2:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+  it('handles thinking events before writing starts', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+    return _regeneratorRuntime.wrap(function (_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          orchestratorMock.mockResolvedValue(createSseResponse([{
+            event: 'thinking',
+            data: {
+              i: 0,
+              delta: 'Analizando'
+            }
+          }, {
+            event: 'complete',
+            data: {
+              content: 'Listo'
+            }
+          }]));
+          _context9.next = 1;
+          return sessionStreamManager.startStream(baseStartParams);
+        case 1:
+          jest.runAllTimers();
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'complete'
+          });
+        case 2:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9);
+  })));
+  it('clears accumulated content on answer_reset', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0() {
+    var onStreamUpdate;
+    return _regeneratorRuntime.wrap(function (_context0) {
+      while (1) switch (_context0.prev = _context0.next) {
+        case 0:
+          onStreamUpdate = jest.fn();
+          orchestratorMock.mockResolvedValue(createSseResponse([{
+            event: 'token',
+            data: {
+              content: 'Borrar'
+            }
+          }, {
+            event: 'answer_reset',
+            data: {}
+          }, {
+            event: 'token',
+            data: {
+              content: 'Nuevo'
+            }
+          }, {
+            event: 'complete',
+            data: {
+              content: 'Nuevo'
+            }
+          }]));
+          _context0.next = 1;
+          return sessionStreamManager.startStream(_objectSpread(_objectSpread({}, baseStartParams), {}, {
+            callbacks: {
+              onStreamUpdate: onStreamUpdate
+            }
+          }));
+        case 1:
+          jest.runAllTimers();
+          expect(onStreamUpdate).toHaveBeenLastCalledWith('Nuevo');
+        case 2:
+        case "end":
+          return _context0.stop();
+      }
+    }, _callee0);
+  })));
+  it('keeps streaming when approval is pre-approved', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee1() {
+    return _regeneratorRuntime.wrap(function (_context1) {
+      while (1) switch (_context1.prev = _context1.next) {
+        case 0:
+          orchestratorMock.mockResolvedValue(createSseResponse([{
+            event: 'approval_required',
+            data: {
+              session_id: 'session-1',
+              auto_approved: true,
+              pending_actions: [{
+                thread_id: 't1',
+                tool_name: 'create_task'
+              }]
+            }
+          }, {
+            event: 'complete',
+            data: {
+              content: 'Hecho'
+            }
+          }]));
+          _context1.next = 1;
+          return sessionStreamManager.startStream(baseStartParams);
+        case 1:
+          jest.runAllTimers();
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'complete'
+          });
+        case 2:
+        case "end":
+          return _context1.stop();
+      }
+    }, _callee1);
+  })));
+  it('abortSilently resets an active stream without marking cancelled', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+    var pending;
+    return _regeneratorRuntime.wrap(function (_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          orchestratorMock.mockResolvedValue(createHangingSseResponse());
+          pending = sessionStreamManager.startStream(baseStartParams);
+          expect(sessionStreamManager.getActiveSessionIds()).toEqual(['session-1']);
+          sessionStreamManager.abortSilently('session-1');
+          _context10.next = 1;
+          return pending;
+        case 1:
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'idle',
+            isLoading: false,
+            isWriting: false
+          });
+        case 2:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee10);
+  })));
+  it('completes streams from content events and reads suggestions[]', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee11() {
+    var onFinishStream;
+    return _regeneratorRuntime.wrap(function (_context11) {
+      while (1) switch (_context11.prev = _context11.next) {
+        case 0:
+          onFinishStream = jest.fn();
+          orchestratorMock.mockResolvedValue(createSseResponse([{
+            event: 'content',
+            data: {
+              content: 'Final',
+              memory_session_id: 'mem-9',
+              suggestions: ['Siguiente'],
+              agent_id: 'agent-9'
+            }
+          }]));
+          _context11.next = 1;
+          return sessionStreamManager.startStream(_objectSpread(_objectSpread({}, baseStartParams), {}, {
+            callbacks: {
+              onFinishStream: onFinishStream
+            }
+          }));
+        case 1:
+          jest.runAllTimers();
+          expect(onFinishStream).toHaveBeenCalledWith(expect.objectContaining({
+            content: 'Final',
+            suggestions: ['Siguiente'],
+            completedAgentId: 'agent-9'
+          }));
+        case 2:
+        case "end":
+          return _context11.stop();
+      }
+    }, _callee11);
+  })));
+  it('updates activity on reasoning_step and node events', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee12() {
+    return _regeneratorRuntime.wrap(function (_context12) {
+      while (1) switch (_context12.prev = _context12.next) {
+        case 0:
+          orchestratorMock.mockResolvedValue(createSseResponse([{
+            event: 'node',
+            data: {
+              node: 'agent_transfer'
+            }
+          }, {
+            event: 'reasoning_step',
+            data: {
+              i: 0,
+              tool: 'web_search',
+              type: 'tool',
+              status: 'running'
+            }
+          }, {
+            event: 'node',
+            data: {
+              message: 'Esperando aprobación',
+              thread_id: 'thread-1'
+            }
+          }, {
+            event: 'complete',
+            data: {
+              content: 'Listo'
+            }
+          }]));
+          _context12.next = 1;
+          return sessionStreamManager.startStream(baseStartParams);
+        case 1:
+          jest.runAllTimers();
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'complete',
+            isLoading: false,
+            isWriting: false
+          });
+        case 2:
+        case "end":
+          return _context12.stop();
+      }
+    }, _callee12);
+  })));
+  it('warns on unknown SSE events without breaking the stream', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee13() {
+    var warnSpy;
+    return _regeneratorRuntime.wrap(function (_context13) {
+      while (1) switch (_context13.prev = _context13.next) {
+        case 0:
+          warnSpy = jest.spyOn(console, 'warn').mockImplementation(function () {
+            return undefined;
+          });
+          orchestratorMock.mockResolvedValue(createSseResponse([{
+            event: 'unknown_event',
+            data: {}
+          }, {
+            event: 'complete',
+            data: {
+              content: 'Ok'
+            }
+          }]));
+          _context13.next = 1;
+          return sessionStreamManager.startStream(baseStartParams);
+        case 1:
+          jest.runAllTimers();
+          expect(warnSpy).toHaveBeenCalled();
+          warnSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context13.stop();
+      }
+    }, _callee13);
+  })));
+  it('returns already_active and limit for continue streams', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee14() {
+    var blocked, limited;
+    return _regeneratorRuntime.wrap(function (_context14) {
+      while (1) switch (_context14.prev = _context14.next) {
+        case 0:
+          orchestratorMock.mockResolvedValue(createHangingSseResponse());
+          sessionStreamManager.startStream(baseStartParams)["catch"](function () {
+            return undefined;
+          });
+          _context14.next = 1;
+          return Promise.resolve();
+        case 1:
+          _context14.next = 2;
+          return sessionStreamManager.startContinueStream({
+            sessionId: 'session-1',
+            placeholderId: 'placeholder-1',
+            continueRequest: {
+              thread_ids: ['t1'],
+              session_id: 'session-1',
+              decision: 'approve'
+            },
+            callbacks: {},
+            t: t
+          });
+        case 2:
+          blocked = _context14.sent;
+          expect(blocked).toEqual({
+            started: false,
+            reason: 'already_active'
+          });
+          sessionStreamManager.abortAll();
+          continueThreadMock.mockResolvedValue(createHangingSseResponse());
+          ['c1', 'c2', 'c3', 'c4'].forEach(function (sessionId) {
+            sessionStreamManager.startContinueStream({
+              sessionId: sessionId,
+              placeholderId: "ph-".concat(sessionId),
+              continueRequest: {
+                thread_ids: ['t1'],
+                session_id: sessionId,
+                decision: 'approve'
+              },
+              callbacks: {},
+              t: t
+            })["catch"](function () {
+              return undefined;
+            });
+          });
+          _context14.next = 3;
+          return Promise.resolve();
+        case 3:
+          _context14.next = 4;
+          return sessionStreamManager.startContinueStream({
+            sessionId: 'c5',
+            placeholderId: 'ph-c5',
+            continueRequest: {
+              thread_ids: ['t1'],
+              session_id: 'c5',
+              decision: 'approve'
+            },
+            callbacks: {},
+            t: t
+          });
+        case 4:
+          limited = _context14.sent;
+          expect(limited).toEqual({
+            started: false,
+            reason: 'limit'
+          });
+          sessionStreamManager.abortAll();
+        case 5:
+        case "end":
+          return _context14.stop();
+      }
+    }, _callee14);
+  })));
+  it('maps orchestrator failures to session error callbacks', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee15() {
+    var onError;
+    return _regeneratorRuntime.wrap(function (_context15) {
+      while (1) switch (_context15.prev = _context15.next) {
+        case 0:
+          onError = jest.fn();
+          orchestratorMock.mockRejectedValue(new Error('network'));
+          _context15.next = 1;
+          return sessionStreamManager.startStream(_objectSpread(_objectSpread({}, baseStartParams), {}, {
+            callbacks: {
+              onError: onError
+            }
+          }));
+        case 1:
+          expect(onError).toHaveBeenCalled();
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'error'
+          });
+        case 2:
+        case "end":
+          return _context15.stop();
+      }
+    }, _callee15);
+  })));
+  it('ignores stopStream when the session is not active', function () {
+    expect(function () {
+      return sessionStreamManager.stopStream('missing-session');
+    }).not.toThrow();
+  });
+  it('returns turn_not_found only for the expected 404 detail', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee16() {
+    var result;
+    return _regeneratorRuntime.wrap(function (_context16) {
+      while (1) switch (_context16.prev = _context16.next) {
+        case 0:
+          retryCompletionMock.mockResolvedValue(createJsonResponse({
+            detail: 'Other error'
+          }, 404));
+          _context16.next = 1;
+          return sessionStreamManager.startRetryStream({
+            sessionId: 'session-1',
+            placeholderId: 'placeholder-1',
+            retryRequest: {
+              session_id: 'session-1',
+              turn_id: 'missing'
+            },
+            callbacks: {},
+            t: t
+          });
+        case 1:
+          result = _context16.sent;
+          expect(result).toEqual({
+            started: true
+          });
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'error'
+          });
+        case 2:
+        case "end":
+          return _context16.stop();
+      }
+    }, _callee16);
+  })));
+  it('maps missing stream readers to session errors', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee17() {
+    var onError;
+    return _regeneratorRuntime.wrap(function (_context17) {
+      while (1) switch (_context17.prev = _context17.next) {
+        case 0:
+          onError = jest.fn();
+          orchestratorMock.mockResolvedValue({
+            ok: true,
+            status: 200,
+            body: null
+          });
+          _context17.next = 1;
+          return sessionStreamManager.startStream(_objectSpread(_objectSpread({}, baseStartParams), {}, {
+            callbacks: {
+              onError: onError
+            }
+          }));
+        case 1:
+          expect(onError).toHaveBeenCalled();
+          expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({
+            status: 'error'
+          });
+        case 2:
+        case "end":
+          return _context17.stop();
+      }
+    }, _callee17);
+  })));
+  it('batches rapid token updates through the throttle window', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee18() {
+    var onStreamUpdate;
+    return _regeneratorRuntime.wrap(function (_context18) {
+      while (1) switch (_context18.prev = _context18.next) {
+        case 0:
+          onStreamUpdate = jest.fn();
+          orchestratorMock.mockResolvedValue(createSseResponse([{
+            event: 'token',
+            data: {
+              content: 'A'
+            }
+          }, {
+            event: 'token',
+            data: {
+              content: 'B'
+            }
+          }, {
+            event: 'complete',
+            data: {
+              content: 'AB'
+            }
+          }]));
+          _context18.next = 1;
+          return sessionStreamManager.startStream(_objectSpread(_objectSpread({}, baseStartParams), {}, {
+            callbacks: {
+              onStreamUpdate: onStreamUpdate
+            }
+          }));
+        case 1:
+          jest.advanceTimersByTime(20);
+          expect(onStreamUpdate).toHaveBeenCalledWith('AB');
+        case 2:
+        case "end":
+          return _context18.stop();
+      }
+    }, _callee18);
+  })));
+  it('surfaces parse errors for malformed SSE payloads', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee19() {
+    var errorSpy, reader;
+    return _regeneratorRuntime.wrap(function (_context19) {
+      while (1) switch (_context19.prev = _context19.next) {
+        case 0:
+          errorSpy = jest.spyOn(console, 'error').mockImplementation(function () {
+            return undefined;
+          });
+          reader = {
+            read: jest.fn().mockResolvedValueOnce({
+              done: false,
+              value: new TextEncoder().encode('event: token\ndata: not-json\n\n')
+            }).mockResolvedValueOnce({
+              done: true
+            }),
+            cancel: jest.fn()
+          };
+          orchestratorMock.mockResolvedValue({
+            ok: true,
+            status: 200,
+            body: {
+              getReader: function getReader() {
+                return reader;
+              }
+            }
+          });
+          _context19.next = 1;
+          return sessionStreamManager.startStream(baseStartParams);
+        case 1:
+          jest.runAllTimers();
+          expect(errorSpy).toHaveBeenCalled();
+          errorSpy.mockRestore();
+        case 2:
+        case "end":
+          return _context19.stop();
+      }
+    }, _callee19);
+  })));
+  it('returns limit when retry streams reach the cap', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee20() {
+    var blocked;
+    return _regeneratorRuntime.wrap(function (_context20) {
+      while (1) switch (_context20.prev = _context20.next) {
+        case 0:
+          retryCompletionMock.mockResolvedValue(createHangingSseResponse());
+          ['r1', 'r2', 'r3', 'r4'].forEach(function (sessionId) {
+            sessionStreamManager.startRetryStream({
+              sessionId: sessionId,
+              placeholderId: "ph-".concat(sessionId),
+              retryRequest: {
+                session_id: sessionId,
+                turn_id: 'turn-1'
+              },
+              callbacks: {},
+              t: t
+            })["catch"](function () {
+              return undefined;
+            });
+          });
+          _context20.next = 1;
+          return Promise.resolve();
+        case 1:
+          _context20.next = 2;
+          return sessionStreamManager.startRetryStream({
+            sessionId: 'r5',
+            placeholderId: 'ph-r5',
+            retryRequest: {
+              session_id: 'r5',
+              turn_id: 'turn-1'
+            },
+            callbacks: {},
+            t: t
+          });
+        case 2:
+          blocked = _context20.sent;
+          expect(blocked).toEqual({
+            started: false,
+            reason: 'limit'
+          });
+          sessionStreamManager.abortAll();
+        case 3:
+        case "end":
+          return _context20.stop();
+      }
+    }, _callee20);
+  })));
+  it('startContinueStream streams tokens after a successful continue response', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee21() {
+    var onFinishStream;
+    return _regeneratorRuntime.wrap(function (_context21) {
+      while (1) switch (_context21.prev = _context21.next) {
+        case 0:
+          onFinishStream = jest.fn();
+          continueThreadMock.mockResolvedValue(createSseResponse([{
+            event: 'token',
+            data: {
+              content: 'Continuación'
+            }
+          }, {
+            event: 'complete',
+            data: {
+              content: 'Continuación'
+            }
+          }]));
+          _context21.next = 1;
+          return sessionStreamManager.startContinueStream({
+            sessionId: 'session-1',
+            placeholderId: 'placeholder-1',
+            continueRequest: {
+              thread_ids: ['t1'],
+              session_id: 'session-1',
+              decision: 'approve'
+            },
+            callbacks: {
+              onFinishStream: onFinishStream
+            },
+            t: t
+          });
+        case 1:
+          jest.runAllTimers();
+          expect(onFinishStream).toHaveBeenCalledWith(expect.objectContaining({
+            content: 'Continuación'
+          }));
+        case 2:
+        case "end":
+          return _context21.stop();
+      }
+    }, _callee21);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["maia","createHangingSseResponse","createJsonResponse","createSseResponse","sessionStreamingText","MAX_CONCURRENT_STREAMS","sessionStreamManager","useSessionsStore","jest","mock","__esModule","Orchestrator","orchestrator","fn","continueThread","retryCompletion","ensureSessionNotificationsInitialized","orchestratorMock","continueThreadMock","retryCompletionMock","t","key","baseStartParams","sessionId","placeholderId","request","message","callbacks","resetState","abortAll","clearAll","setState","meta","messages","viewCache","clearAllMocks","describe","beforeEach","useFakeTimers","afterEach","useRealTimers","it","expect","toBe","_asyncToGenerator","_regeneratorRuntime","mark","_callee","second","wrap","_context","prev","next","mockResolvedValue","startStream","undefined","Promise","resolve","sent","toEqual","started","reason","isActive","stopStream","stop","_callee2","blocked","_context2","forEach","_objectSpread","concat","getActiveCount","_callee3","onStartWriting","onStreamUpdate","onFinishStream","result","_context3","event","data","content","memory_session_id","suggest_reply","runAllTimers","toHaveBeenCalled","toHaveBeenCalledWith","objectContaining","memorySessionId","suggestions","getState","getMeta","toMatchObject","status","isLoading","isWriting","_callee4","onError","_context4","error","type","_callee5","onApprovalRequired","_context5","session_id","pending_actions","thread_id","tool_name","getSnapshot","text","_callee6","onStop","_context6","setText","_callee7","_context7","detail","startContinueStream","continueRequest","thread_ids","decision","_callee8","_context8","startRetryStream","retryRequest","turn_id","_callee9","_context9","i","delta","_callee0","_context0","toHaveBeenLastCalledWith","_callee1","_context1","auto_approved","_callee10","pending","_context10","getActiveSessionIds","abortSilently","_callee11","_context11","agent_id","completedAgentId","_callee12","_context12","node","tool","_callee13","warnSpy","_context13","spyOn","console","mockImplementation","mockRestore","_callee14","limited","_context14","_callee15","_context15","mockRejectedValue","Error","not","toThrow","_callee16","_context16","_callee17","_context17","ok","body","_callee18","_context18","advanceTimersByTime","_callee19","errorSpy","reader","_context19","read","mockResolvedValueOnce","done","value","TextEncoder","encode","cancel","getReader","_callee20","_context20","_callee21","_context21"],"sources":["../../../src/store/sessions/sessionStreamManager.spec.ts"],"sourcesContent":["import maia from '../../services/maia'\nimport { createHangingSseResponse, createJsonResponse, createSseResponse } from '../../test/mockSseStream'\nimport { sessionStreamingText } from './sessionStreamingText'\nimport { MAX_CONCURRENT_STREAMS, sessionStreamManager } from './sessionStreamManager'\nimport { useSessionsStore } from './useSessionsStore'\n\njest.mock('../../services/maia', () => ({\n  __esModule: true,\n  default: {\n    Orchestrator: {\n      orchestrator: jest.fn(),\n      continueThread: jest.fn(),\n      retryCompletion: jest.fn(),\n    },\n  },\n}))\n\njest.mock('./sessionNotifications', () => ({\n  ensureSessionNotificationsInitialized: jest.fn(),\n}))\n\nconst orchestratorMock = maia.Orchestrator.orchestrator as jest.Mock\nconst continueThreadMock = maia.Orchestrator.continueThread as jest.Mock\nconst retryCompletionMock = maia.Orchestrator.retryCompletion as jest.Mock\n\nconst t = (key: string) => key\n\nconst baseStartParams = {\n  sessionId: 'session-1',\n  placeholderId: 'placeholder-1',\n  request: { message: 'hola' } as never,\n  callbacks: {},\n  t,\n}\n\nconst resetState = () => {\n  sessionStreamManager.abortAll()\n  sessionStreamingText.clearAll()\n  useSessionsStore.setState({ meta: {}, messages: {}, viewCache: {} })\n  jest.clearAllMocks()\n}\n\ndescribe('sessionStreamManager', () => {\n  beforeEach(() => {\n    resetState()\n    jest.useFakeTimers()\n  })\n\n  afterEach(() => {\n    sessionStreamManager.abortAll()\n    jest.useRealTimers()\n  })\n\n  it('exposes MAX_CONCURRENT_STREAMS as 4', () => {\n    expect(MAX_CONCURRENT_STREAMS).toBe(4)\n  })\n\n  it('returns already_active when the session is already streaming', async () => {\n    orchestratorMock.mockResolvedValue(createHangingSseResponse())\n\n    sessionStreamManager.startStream(baseStartParams).catch(() => undefined)\n    await Promise.resolve()\n\n    const second = await sessionStreamManager.startStream(baseStartParams)\n\n    expect(second).toEqual({ started: false, reason: 'already_active' })\n    expect(sessionStreamManager.isActive('session-1')).toBe(true)\n\n    sessionStreamManager.stopStream('session-1')\n  })\n\n  it('returns limit when concurrent streams reach the cap', async () => {\n    orchestratorMock.mockResolvedValue(createHangingSseResponse())\n\n    ;['s1', 's2', 's3', 's4'].forEach(sessionId => {\n      sessionStreamManager\n        .startStream({ ...baseStartParams, sessionId, placeholderId: `ph-${sessionId}` })\n        .catch(() => undefined)\n    })\n    await Promise.resolve()\n\n    expect(sessionStreamManager.getActiveCount()).toBe(4)\n\n    const blocked = await sessionStreamManager.startStream({\n      ...baseStartParams,\n      sessionId: 's5',\n      placeholderId: 'ph-s5',\n    })\n\n    expect(blocked).toEqual({ started: false, reason: 'limit' })\n\n    sessionStreamManager.abortAll()\n  })\n\n  it('streams tokens and completes with store + callbacks updated', async () => {\n    const onStartWriting = jest.fn()\n    const onStreamUpdate = jest.fn()\n    const onFinishStream = jest.fn()\n\n    orchestratorMock.mockResolvedValue(\n      createSseResponse([\n        { event: 'token', data: { content: 'Hola' } },\n        { event: 'token', data: { content: ' mundo' } },\n        {\n          event: 'complete',\n          data: {\n            content: 'Hola mundo',\n            memory_session_id: 'mem-1',\n            suggest_reply: ['¿Algo más?'],\n          },\n        },\n      ])\n    )\n\n    const result = await sessionStreamManager.startStream({\n      ...baseStartParams,\n      callbacks: { onStartWriting, onStreamUpdate, onFinishStream },\n    })\n\n    jest.runAllTimers()\n\n    expect(result).toEqual({ started: true })\n    expect(onStartWriting).toHaveBeenCalled()\n    expect(onStreamUpdate).toHaveBeenCalledWith('Hola mundo')\n    expect(onFinishStream).toHaveBeenCalledWith(\n      expect.objectContaining({\n        content: 'Hola mundo',\n        memorySessionId: 'mem-1',\n        suggestions: ['¿Algo más?'],\n      })\n    )\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({\n      status: 'complete',\n      isLoading: false,\n      isWriting: false,\n    })\n    expect(sessionStreamManager.isActive('session-1')).toBe(false)\n  })\n\n  it('maps SSE error events to session error state', async () => {\n    const onError = jest.fn()\n\n    orchestratorMock.mockResolvedValue(\n      createSseResponse([{ event: 'error', data: { error: { type: 'rate_limit', message: 'Too many requests' } } }])\n    )\n\n    await sessionStreamManager.startStream({\n      ...baseStartParams,\n      callbacks: { onError },\n    })\n\n    jest.runAllTimers()\n\n    expect(onError).toHaveBeenCalledWith('rate_limit', 'Too many requests')\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({\n      status: 'error',\n      isLoading: false,\n      isWriting: false,\n      error: { type: 'rate_limit', message: 'Too many requests' },\n    })\n  })\n\n  it('requires approval and clears live text when not pre-approved', async () => {\n    const onApprovalRequired = jest.fn()\n\n    orchestratorMock.mockResolvedValue(\n      createSseResponse([\n        { event: 'token', data: { content: 'Parcial' } },\n        {\n          event: 'approval_required',\n          data: {\n            session_id: 'session-1',\n            pending_actions: [{ thread_id: 't1', tool_name: 'create_task' }],\n          },\n        },\n      ])\n    )\n\n    await sessionStreamManager.startStream({\n      ...baseStartParams,\n      callbacks: { onApprovalRequired },\n    })\n\n    jest.runAllTimers()\n\n    expect(onApprovalRequired).toHaveBeenCalledWith(expect.objectContaining({ session_id: 'session-1' }), 'Parcial')\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({\n      status: 'awaiting_approval',\n      isWriting: false,\n    })\n    expect(sessionStreamingText.getSnapshot('session-1').text).toBe('')\n  })\n\n  it('stopStream aborts the stream and marks the session as cancelled', async () => {\n    const onStop = jest.fn()\n\n    orchestratorMock.mockResolvedValue(createHangingSseResponse())\n\n    sessionStreamManager\n      .startStream({\n        ...baseStartParams,\n        callbacks: { onStop },\n      })\n      .catch(() => undefined)\n    await Promise.resolve()\n\n    sessionStreamingText.setText('session-1', 'placeholder-1', 'Texto parcial')\n    sessionStreamManager.stopStream('session-1', { onStop })\n\n    expect(onStop).toHaveBeenCalledWith('Texto parcial')\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({\n      status: 'cancelled',\n      isLoading: false,\n      isWriting: false,\n    })\n  })\n\n  it('startContinueStream rejects non-ok responses', async () => {\n    const onError = jest.fn()\n    continueThreadMock.mockResolvedValue(createJsonResponse({ detail: 'fail' }, 500))\n\n    const result = await sessionStreamManager.startContinueStream({\n      sessionId: 'session-1',\n      placeholderId: 'placeholder-1',\n      continueRequest: { thread_ids: ['t1'], session_id: 'session-1', decision: 'approve' } as never,\n      callbacks: { onError },\n      t,\n    })\n\n    expect(result).toEqual({ started: true })\n    expect(onError).toHaveBeenCalled()\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({ status: 'error' })\n  })\n\n  it('startRetryStream returns turn_not_found on 404', async () => {\n    retryCompletionMock.mockResolvedValue(createJsonResponse({ detail: 'Turn not found' }, 404))\n\n    const result = await sessionStreamManager.startRetryStream({\n      sessionId: 'session-1',\n      placeholderId: 'placeholder-1',\n      retryRequest: { session_id: 'session-1', turn_id: 'missing' } as never,\n      callbacks: {},\n      t,\n    })\n\n    expect(result).toEqual({ started: false, reason: 'turn_not_found' })\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({\n      status: 'idle',\n      isLoading: false,\n      isWriting: false,\n    })\n  })\n\n  it('handles thinking events before writing starts', async () => {\n    orchestratorMock.mockResolvedValue(\n      createSseResponse([\n        { event: 'thinking', data: { i: 0, delta: 'Analizando' } },\n        { event: 'complete', data: { content: 'Listo' } },\n      ])\n    )\n\n    await sessionStreamManager.startStream(baseStartParams)\n    jest.runAllTimers()\n\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({\n      status: 'complete',\n    })\n  })\n\n  it('clears accumulated content on answer_reset', async () => {\n    const onStreamUpdate = jest.fn()\n\n    orchestratorMock.mockResolvedValue(\n      createSseResponse([\n        { event: 'token', data: { content: 'Borrar' } },\n        { event: 'answer_reset', data: {} },\n        { event: 'token', data: { content: 'Nuevo' } },\n        { event: 'complete', data: { content: 'Nuevo' } },\n      ])\n    )\n\n    await sessionStreamManager.startStream({\n      ...baseStartParams,\n      callbacks: { onStreamUpdate },\n    })\n    jest.runAllTimers()\n\n    expect(onStreamUpdate).toHaveBeenLastCalledWith('Nuevo')\n  })\n\n  it('keeps streaming when approval is pre-approved', async () => {\n    orchestratorMock.mockResolvedValue(\n      createSseResponse([\n        {\n          event: 'approval_required',\n          data: {\n            session_id: 'session-1',\n            auto_approved: true,\n            pending_actions: [{ thread_id: 't1', tool_name: 'create_task' }],\n          },\n        },\n        { event: 'complete', data: { content: 'Hecho' } },\n      ])\n    )\n\n    await sessionStreamManager.startStream(baseStartParams)\n    jest.runAllTimers()\n\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({\n      status: 'complete',\n    })\n  })\n\n  it('abortSilently resets an active stream without marking cancelled', async () => {\n    orchestratorMock.mockResolvedValue(createHangingSseResponse())\n\n    const pending = sessionStreamManager.startStream(baseStartParams)\n    expect(sessionStreamManager.getActiveSessionIds()).toEqual(['session-1'])\n\n    sessionStreamManager.abortSilently('session-1')\n    await pending\n\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({\n      status: 'idle',\n      isLoading: false,\n      isWriting: false,\n    })\n  })\n\n  it('completes streams from content events and reads suggestions[]', async () => {\n    const onFinishStream = jest.fn()\n\n    orchestratorMock.mockResolvedValue(\n      createSseResponse([\n        {\n          event: 'content',\n          data: { content: 'Final', memory_session_id: 'mem-9', suggestions: ['Siguiente'], agent_id: 'agent-9' },\n        },\n      ])\n    )\n\n    await sessionStreamManager.startStream({\n      ...baseStartParams,\n      callbacks: { onFinishStream },\n    })\n    jest.runAllTimers()\n\n    expect(onFinishStream).toHaveBeenCalledWith(\n      expect.objectContaining({\n        content: 'Final',\n        suggestions: ['Siguiente'],\n        completedAgentId: 'agent-9',\n      })\n    )\n  })\n\n  it('updates activity on reasoning_step and node events', async () => {\n    orchestratorMock.mockResolvedValue(\n      createSseResponse([\n        { event: 'node', data: { node: 'agent_transfer' } },\n        { event: 'reasoning_step', data: { i: 0, tool: 'web_search', type: 'tool', status: 'running' } },\n        { event: 'node', data: { message: 'Esperando aprobación', thread_id: 'thread-1' } },\n        { event: 'complete', data: { content: 'Listo' } },\n      ])\n    )\n\n    await sessionStreamManager.startStream(baseStartParams)\n    jest.runAllTimers()\n\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({\n      status: 'complete',\n      isLoading: false,\n      isWriting: false,\n    })\n  })\n\n  it('warns on unknown SSE events without breaking the stream', async () => {\n    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined)\n\n    orchestratorMock.mockResolvedValue(\n      createSseResponse([\n        { event: 'unknown_event', data: {} },\n        { event: 'complete', data: { content: 'Ok' } },\n      ])\n    )\n\n    await sessionStreamManager.startStream(baseStartParams)\n    jest.runAllTimers()\n\n    expect(warnSpy).toHaveBeenCalled()\n    warnSpy.mockRestore()\n  })\n\n  it('returns already_active and limit for continue streams', async () => {\n    orchestratorMock.mockResolvedValue(createHangingSseResponse())\n    sessionStreamManager.startStream(baseStartParams).catch(() => undefined)\n    await Promise.resolve()\n\n    const blocked = await sessionStreamManager.startContinueStream({\n      sessionId: 'session-1',\n      placeholderId: 'placeholder-1',\n      continueRequest: { thread_ids: ['t1'], session_id: 'session-1', decision: 'approve' } as never,\n      callbacks: {},\n      t,\n    })\n    expect(blocked).toEqual({ started: false, reason: 'already_active' })\n\n    sessionStreamManager.abortAll()\n    continueThreadMock.mockResolvedValue(createHangingSseResponse())\n    ;['c1', 'c2', 'c3', 'c4'].forEach(sessionId => {\n      sessionStreamManager\n        .startContinueStream({\n          sessionId,\n          placeholderId: `ph-${sessionId}`,\n          continueRequest: { thread_ids: ['t1'], session_id: sessionId, decision: 'approve' } as never,\n          callbacks: {},\n          t,\n        })\n        .catch(() => undefined)\n    })\n    await Promise.resolve()\n\n    const limited = await sessionStreamManager.startContinueStream({\n      sessionId: 'c5',\n      placeholderId: 'ph-c5',\n      continueRequest: { thread_ids: ['t1'], session_id: 'c5', decision: 'approve' } as never,\n      callbacks: {},\n      t,\n    })\n    expect(limited).toEqual({ started: false, reason: 'limit' })\n    sessionStreamManager.abortAll()\n  })\n\n  it('maps orchestrator failures to session error callbacks', async () => {\n    const onError = jest.fn()\n    orchestratorMock.mockRejectedValue(new Error('network'))\n\n    await sessionStreamManager.startStream({\n      ...baseStartParams,\n      callbacks: { onError },\n    })\n\n    expect(onError).toHaveBeenCalled()\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({ status: 'error' })\n  })\n\n  it('ignores stopStream when the session is not active', () => {\n    expect(() => sessionStreamManager.stopStream('missing-session')).not.toThrow()\n  })\n\n  it('returns turn_not_found only for the expected 404 detail', async () => {\n    retryCompletionMock.mockResolvedValue(createJsonResponse({ detail: 'Other error' }, 404))\n\n    const result = await sessionStreamManager.startRetryStream({\n      sessionId: 'session-1',\n      placeholderId: 'placeholder-1',\n      retryRequest: { session_id: 'session-1', turn_id: 'missing' } as never,\n      callbacks: {},\n      t,\n    })\n\n    expect(result).toEqual({ started: true })\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({ status: 'error' })\n  })\n\n  it('maps missing stream readers to session errors', async () => {\n    const onError = jest.fn()\n    orchestratorMock.mockResolvedValue({\n      ok: true,\n      status: 200,\n      body: null,\n    } as unknown as Response)\n\n    await sessionStreamManager.startStream({\n      ...baseStartParams,\n      callbacks: { onError },\n    })\n\n    expect(onError).toHaveBeenCalled()\n    expect(useSessionsStore.getState().getMeta('session-1')).toMatchObject({ status: 'error' })\n  })\n\n  it('batches rapid token updates through the throttle window', async () => {\n    const onStreamUpdate = jest.fn()\n\n    orchestratorMock.mockResolvedValue(\n      createSseResponse([\n        { event: 'token', data: { content: 'A' } },\n        { event: 'token', data: { content: 'B' } },\n        { event: 'complete', data: { content: 'AB' } },\n      ])\n    )\n\n    await sessionStreamManager.startStream({\n      ...baseStartParams,\n      callbacks: { onStreamUpdate },\n    })\n\n    jest.advanceTimersByTime(20)\n\n    expect(onStreamUpdate).toHaveBeenCalledWith('AB')\n  })\n\n  it('surfaces parse errors for malformed SSE payloads', async () => {\n    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined)\n    const reader = {\n      read: jest\n        .fn()\n        .mockResolvedValueOnce({\n          done: false,\n          value: new TextEncoder().encode('event: token\\ndata: not-json\\n\\n'),\n        })\n        .mockResolvedValueOnce({ done: true }),\n      cancel: jest.fn(),\n    }\n\n    orchestratorMock.mockResolvedValue({\n      ok: true,\n      status: 200,\n      body: { getReader: () => reader },\n    } as unknown as Response)\n\n    await sessionStreamManager.startStream(baseStartParams)\n    jest.runAllTimers()\n\n    expect(errorSpy).toHaveBeenCalled()\n    errorSpy.mockRestore()\n  })\n\n  it('returns limit when retry streams reach the cap', async () => {\n    retryCompletionMock.mockResolvedValue(createHangingSseResponse())\n    ;['r1', 'r2', 'r3', 'r4'].forEach(sessionId => {\n      sessionStreamManager\n        .startRetryStream({\n          sessionId,\n          placeholderId: `ph-${sessionId}`,\n          retryRequest: { session_id: sessionId, turn_id: 'turn-1' } as never,\n          callbacks: {},\n          t,\n        })\n        .catch(() => undefined)\n    })\n    await Promise.resolve()\n\n    const blocked = await sessionStreamManager.startRetryStream({\n      sessionId: 'r5',\n      placeholderId: 'ph-r5',\n      retryRequest: { session_id: 'r5', turn_id: 'turn-1' } as never,\n      callbacks: {},\n      t,\n    })\n\n    expect(blocked).toEqual({ started: false, reason: 'limit' })\n    sessionStreamManager.abortAll()\n  })\n\n  it('startContinueStream streams tokens after a successful continue response', async () => {\n    const onFinishStream = jest.fn()\n    continueThreadMock.mockResolvedValue(\n      createSseResponse([\n        { event: 'token', data: { content: 'Continuación' } },\n        { event: 'complete', data: { content: 'Continuación' } },\n      ])\n    )\n\n    await sessionStreamManager.startContinueStream({\n      sessionId: 'session-1',\n      placeholderId: 'placeholder-1',\n      continueRequest: { thread_ids: ['t1'], session_id: 'session-1', decision: 'approve' } as never,\n      callbacks: { onFinishStream },\n      t,\n    })\n    jest.runAllTimers()\n\n    expect(onFinishStream).toHaveBeenCalledWith(expect.objectContaining({ content: 'Continuación' }))\n  })\n})\n"],"mappings":"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","ignoreList":[]}