@projectcor/maia-components 2.45.0 → 2.45.1-0

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

@@ -0,0 +1,503 @@
+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);
+  })));
+});
+//# 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"],"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"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,16 @@
+import { isActiveSessionStatus } from './sessions.types';
+describe('isActiveSessionStatus', function () {
+  it('treats thinking, writing and awaiting_approval as active', function () {
+    expect(isActiveSessionStatus('thinking')).toBe(true);
+    expect(isActiveSessionStatus('writing')).toBe(true);
+    expect(isActiveSessionStatus('awaiting_approval')).toBe(true);
+  });
+  it('treats idle and terminal states as inactive', function () {
+    expect(isActiveSessionStatus('idle')).toBe(false);
+    expect(isActiveSessionStatus('complete')).toBe(false);
+    expect(isActiveSessionStatus('error')).toBe(false);
+    expect(isActiveSessionStatus('cancelled')).toBe(false);
+    expect(isActiveSessionStatus(undefined)).toBe(false);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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