@projectcor/maia-components 2.11.78-16 → 2.11.78-2

package/lib/store/sessions/sessionStreamManager.js

@@ -0,0 +1,585 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/* eslint-disable no-console */
+/* eslint-disable no-continue */
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable no-constant-condition */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import maia from '../../services/maia';
+import { getInitialStreamActivity, getThinkingLoadingMessage, getWritingStreamActivity, resolveHitlNodeStreamActivity, resolveInitialHitlStreamActivity } from '../../utils/streamActivityMessages';
+import { isCompleteLikeSsePayload, mergeStreamChunk } from '../../utils/sseStreamContent';
+import { sessionStreamingText } from './sessionStreamingText';
+import { useSessionsStore } from './useSessionsStore';
+import { ensureSessionNotificationsInitialized } from './sessionNotifications';
+import { ensureSessionInSidebarFromRequest } from '../chatsSidebarOptimistic';
+import { sessionHitlContext } from './sessionHitlContext';
+
+/** Compatible con el `t` de i18next (uso de una sola key). */
+
+/**
+ * Máximo de sesiones generando en paralelo. Protege red/recursos del cliente.
+ * Ajustable a futuro vía flag del host.
+ */
+export var MAX_CONCURRENT_STREAMS = 4;
+var STREAM_THROTTLE_MS = 16;
+var activeStreams = new Map();
+var store = function store() {
+  return useSessionsStore.getState();
+};
+var isStreamActive = function isStreamActive(sessionId) {
+  return activeStreams.has(sessionId);
+};
+var getActiveStreamCount = function getActiveStreamCount() {
+  return activeStreams.size;
+};
+var parseSessionSSE = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(response, active, params) {
+    var _params$hitlExecution, _response$body, _data$error, _data$error2, _callbacks$onError, _data$error3, _data$error4;
+    var sessionId, placeholderId, callbacks, t, hitlExecutionContext, pendingContent, throttleTimer, flushToStores, emitThrottled, flushPending, reader, decoder, buffer, accumulatedContent, hasStartedWriting, hasAddedToSidebar, maybeAddSessionToSidebar, ensureWritingStarted, applyStreamChunk, applyStreamComplete, _yield$reader$read, done, value, lines, _iterator, _step, line, _line$split, _line$split2, eventLine, dataLine, eventType, dataStr, data, chunk, _chunk, _callbacks$onApproval, isManualApproval, _t, _t2, _t3;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          sessionId = params.sessionId, placeholderId = params.placeholderId, callbacks = params.callbacks, t = params.t;
+          hitlExecutionContext = (_params$hitlExecution = params.hitlExecutionContext) !== null && _params$hitlExecution !== void 0 ? _params$hitlExecution : sessionHitlContext.get(sessionId);
+          pendingContent = null;
+          throttleTimer = null;
+          flushToStores = function flushToStores(content) {
+            var _callbacks$onStreamUp;
+            sessionStreamingText.setText(sessionId, placeholderId, content);
+            (_callbacks$onStreamUp = callbacks.onStreamUpdate) === null || _callbacks$onStreamUp === void 0 || _callbacks$onStreamUp.call(callbacks, content);
+          };
+          emitThrottled = function emitThrottled(content) {
+            pendingContent = content;
+            if (throttleTimer != null) return;
+            throttleTimer = window.setTimeout(function () {
+              throttleTimer = null;
+              if (pendingContent != null) {
+                var toEmit = pendingContent;
+                pendingContent = null;
+                flushToStores(toEmit);
+              }
+            }, STREAM_THROTTLE_MS);
+          };
+          flushPending = function flushPending() {
+            if (throttleTimer != null) {
+              window.clearTimeout(throttleTimer);
+              throttleTimer = null;
+            }
+            if (pendingContent != null) {
+              var toEmit = pendingContent;
+              pendingContent = null;
+              flushToStores(toEmit);
+            }
+          };
+          reader = (_response$body = response.body) === null || _response$body === void 0 ? void 0 : _response$body.getReader();
+          if (reader) {
+            _context.next = 1;
+            break;
+          }
+          throw new Error('No reader available');
+        case 1:
+          decoder = new TextDecoder();
+          buffer = '';
+          accumulatedContent = '';
+          hasStartedWriting = false;
+          hasAddedToSidebar = false;
+          maybeAddSessionToSidebar = function maybeAddSessionToSidebar() {
+            if (hasAddedToSidebar || params.sidebarOnFirstToken === false) return;
+            hasAddedToSidebar = true;
+            ensureSessionInSidebarFromRequest(sessionId, params.request, params.agentEmoji);
+          };
+          ensureWritingStarted = function ensureWritingStarted() {
+            var _callbacks$onStartWri;
+            if (hasStartedWriting) return;
+            hasStartedWriting = true;
+            store().patchMeta(sessionId, {
+              isLoading: true,
+              isWriting: true
+            });
+            store().setStatus(sessionId, 'writing');
+            store().setActivity(sessionId, getWritingStreamActivity(t));
+            (_callbacks$onStartWri = callbacks.onStartWriting) === null || _callbacks$onStartWri === void 0 || _callbacks$onStartWri.call(callbacks);
+          };
+          applyStreamChunk = function applyStreamChunk(chunk) {
+            if (!chunk) return;
+            accumulatedContent = mergeStreamChunk(accumulatedContent, chunk);
+            emitThrottled(accumulatedContent);
+          };
+          applyStreamComplete = function applyStreamComplete(payload) {
+            var _payload$agent_id, _subagentRaw$resolved, _callbacks$onFinishSt;
+            var finalContent = payload.content || accumulatedContent;
+            var sources = payload.sources || null;
+            var memorySessionId = payload.memory_session_id || '';
+            var attachments = Array.isArray(payload.attachments) ? payload.attachments : null;
+            var suggestions = null;
+            if (Array.isArray(payload.suggest_reply)) {
+              suggestions = payload.suggest_reply;
+            } else if (Array.isArray(payload.suggestions)) {
+              suggestions = payload.suggestions;
+            }
+            var agentIdRaw = (_payload$agent_id = payload.agent_id) !== null && _payload$agent_id !== void 0 ? _payload$agent_id : payload.agentId;
+            var completedAgentId = agentIdRaw != null && String(agentIdRaw).trim() !== '' ? String(agentIdRaw).trim() : null;
+            var subagentRaw = payload.subagent;
+            var resolvedContext = (_subagentRaw$resolved = subagentRaw === null || subagentRaw === void 0 ? void 0 : subagentRaw.resolved_context) !== null && _subagentRaw$resolved !== void 0 ? _subagentRaw$resolved : null;
+            flushPending();
+            sessionStreamingText.clear(sessionId);
+            store().patchMeta(sessionId, {
+              isLoading: false,
+              isWriting: false
+            });
+            store().setActivity(sessionId, null);
+            store().setStatus(sessionId, 'complete');
+            var finishPayload = {
+              content: finalContent,
+              sources: sources,
+              memorySessionId: memorySessionId,
+              attachments: attachments,
+              suggestions: suggestions,
+              completedAgentId: completedAgentId,
+              resolvedContext: resolvedContext
+            };
+            (_callbacks$onFinishSt = callbacks.onFinishStream) === null || _callbacks$onFinishSt === void 0 || _callbacks$onFinishSt.call(callbacks, finishPayload);
+          };
+          _context.prev = 2;
+        case 3:
+          if (!true) {
+            _context.next = 28;
+            break;
+          }
+          if (!active.isStopped) {
+            _context.next = 4;
+            break;
+          }
+          reader.cancel();
+          return _context.abrupt("continue", 28);
+        case 4:
+          _context.next = 5;
+          return reader.read();
+        case 5:
+          _yield$reader$read = _context.sent;
+          done = _yield$reader$read.done;
+          value = _yield$reader$read.value;
+          if (!done) {
+            _context.next = 6;
+            break;
+          }
+          return _context.abrupt("continue", 28);
+        case 6:
+          if (!active.isStopped) {
+            _context.next = 7;
+            break;
+          }
+          reader.cancel();
+          return _context.abrupt("continue", 28);
+        case 7:
+          buffer += decoder.decode(value, {
+            stream: true
+          });
+          lines = buffer.split('\n\n');
+          buffer = lines.pop() || '';
+          _iterator = _createForOfIteratorHelper(lines);
+          _context.prev = 8;
+          _iterator.s();
+        case 9:
+          if ((_step = _iterator.n()).done) {
+            _context.next = 24;
+            break;
+          }
+          line = _step.value;
+          if (!(line.trim() === '')) {
+            _context.next = 10;
+            break;
+          }
+          return _context.abrupt("continue", 23);
+        case 10:
+          _line$split = line.split('\n'), _line$split2 = _slicedToArray(_line$split, 2), eventLine = _line$split2[0], dataLine = _line$split2[1];
+          if (!(!eventLine || !dataLine)) {
+            _context.next = 11;
+            break;
+          }
+          return _context.abrupt("continue", 23);
+        case 11:
+          eventType = eventLine.replace('event: ', '').trim();
+          dataStr = dataLine.replace('data: ', '').trim();
+          _context.prev = 12;
+          data = JSON.parse(dataStr);
+          _t = eventType;
+          _context.next = _t === 'thinking' ? 13 : _t === 'token' ? 14 : _t === 'content' ? 15 : _t === 'node' ? 16 : _t === 'complete' ? 17 : _t === 'approval_required' ? 18 : _t === 'error' ? 19 : 20;
+          break;
+        case 13:
+          if (!hasStartedWriting) {
+            store().patchMeta(sessionId, {
+              isLoading: true
+            });
+            store().setStatus(sessionId, 'thinking');
+            store().setActivity(sessionId, {
+              phase: 'thinking',
+              message: getThinkingLoadingMessage(0, t)
+            });
+          }
+          return _context.abrupt("continue", 21);
+        case 14:
+          chunk = typeof data.content === 'string' ? data.content : '';
+          maybeAddSessionToSidebar();
+          ensureWritingStarted();
+          applyStreamChunk(chunk);
+          return _context.abrupt("continue", 21);
+        case 15:
+          _chunk = typeof data.content === 'string' ? data.content : '';
+          ensureWritingStarted();
+          applyStreamChunk(_chunk);
+          if (isCompleteLikeSsePayload(data)) {
+            applyStreamComplete(data);
+          }
+          return _context.abrupt("continue", 21);
+        case 16:
+          if (data.node === 'agent_transfer') {
+            store().patchMeta(sessionId, {
+              isLoading: true
+            });
+            store().setStatus(sessionId, 'thinking');
+          } else if (data.message && typeof data.message === 'string') {
+            store().patchMeta(sessionId, {
+              isLoading: true
+            });
+            store().setStatus(sessionId, 'thinking');
+            store().setActivity(sessionId, resolveHitlNodeStreamActivity(data.message, t, hitlExecutionContext !== null && hitlExecutionContext !== void 0 ? hitlExecutionContext : undefined, typeof data.thread_id === 'string' ? data.thread_id : undefined));
+          }
+          return _context.abrupt("continue", 21);
+        case 17:
+          applyStreamComplete(data);
+          return _context.abrupt("continue", 21);
+        case 18:
+          flushPending();
+          isManualApproval = data.manual_approval_detected === true;
+          store().patchMeta(sessionId, {
+            isWriting: false
+          });
+          if (!isManualApproval) {
+            store().patchMeta(sessionId, {
+              isLoading: false
+            });
+            sessionStreamingText.clear(sessionId);
+            store().setActivity(sessionId, null);
+          }
+          store().setStatus(sessionId, 'awaiting_approval');
+          (_callbacks$onApproval = callbacks.onApprovalRequired) === null || _callbacks$onApproval === void 0 || _callbacks$onApproval.call(callbacks, data, accumulatedContent);
+          if (isManualApproval && Array.isArray(data.pending_actions) && data.pending_actions.length > 0) {
+            store().patchMeta(sessionId, {
+              isLoading: true
+            });
+            store().setStatus(sessionId, 'thinking');
+            store().setActivity(sessionId, resolveInitialHitlStreamActivity(t, hitlExecutionContext !== null && hitlExecutionContext !== void 0 ? hitlExecutionContext : undefined));
+          }
+          return _context.abrupt("continue", 21);
+        case 19:
+          console.error('SSE Error:', data.error);
+          flushPending();
+          sessionStreamingText.clear(sessionId);
+          store().patchMeta(sessionId, {
+            isLoading: false,
+            isWriting: false
+          });
+          store().setActivity(sessionId, null);
+          store().setError(sessionId, {
+            type: (_data$error = data.error) === null || _data$error === void 0 ? void 0 : _data$error.type,
+            message: (_data$error2 = data.error) === null || _data$error2 === void 0 ? void 0 : _data$error2.message
+          });
+          store().setStatus(sessionId, 'error');
+          (_callbacks$onError = callbacks.onError) === null || _callbacks$onError === void 0 || _callbacks$onError.call(callbacks, (_data$error3 = data.error) === null || _data$error3 === void 0 ? void 0 : _data$error3.type, (_data$error4 = data.error) === null || _data$error4 === void 0 ? void 0 : _data$error4.message);
+          return _context.abrupt("continue", 21);
+        case 20:
+          console.warn('Unknown SSE event type:', eventType);
+          return _context.abrupt("continue", 21);
+        case 21:
+          _context.next = 23;
+          break;
+        case 22:
+          _context.prev = 22;
+          _t2 = _context["catch"](12);
+          console.error('Error parsing SSE data:', _t2, dataStr);
+        case 23:
+          _context.next = 9;
+          break;
+        case 24:
+          _context.next = 26;
+          break;
+        case 25:
+          _context.prev = 25;
+          _t3 = _context["catch"](8);
+          _iterator.e(_t3);
+        case 26:
+          _context.prev = 26;
+          _iterator.f();
+          return _context.finish(26);
+        case 27:
+          _context.next = 3;
+          break;
+        case 28:
+          _context.prev = 28;
+          flushPending();
+          return _context.finish(28);
+        case 29:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[2,, 28, 29], [8, 25, 26, 27], [12, 22]]);
+  }));
+  return function parseSessionSSE(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+/**
+ * Manager singleton (module-level) que corre N streams del orchestrator en
+ * paralelo, uno por `sessionId`. Sobrevive a cambios de vista y al cierre del
+ * modal: los streams solo se cancelan con stop explícito del usuario o al
+ * completar/errorar.
+ */
+export var sessionStreamManager = {
+  isActive: isStreamActive,
+  getActiveCount: getActiveStreamCount,
+  getActiveSessionIds: function getActiveSessionIds() {
+    return Array.from(activeStreams.keys());
+  },
+  startStream: function startStream(params) {
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var sessionId, placeholderId, request, callbacks, t, activityOptions, agentId, agentName, controller, active, response, _callbacks$onError2, _t4;
+      return _regeneratorRuntime.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            ensureSessionNotificationsInitialized();
+            sessionId = params.sessionId, placeholderId = params.placeholderId, request = params.request, callbacks = params.callbacks, t = params.t, activityOptions = params.activityOptions, agentId = params.agentId, agentName = params.agentName;
+            if (!isStreamActive(sessionId)) {
+              _context2.next = 1;
+              break;
+            }
+            return _context2.abrupt("return", {
+              started: false,
+              reason: 'already_active'
+            });
+          case 1:
+            if (!(getActiveStreamCount() >= MAX_CONCURRENT_STREAMS)) {
+              _context2.next = 2;
+              break;
+            }
+            return _context2.abrupt("return", {
+              started: false,
+              reason: 'limit'
+            });
+          case 2:
+            controller = new AbortController();
+            active = {
+              sessionId: sessionId,
+              controller: controller,
+              isStopped: false
+            };
+            activeStreams.set(sessionId, active);
+            store().ensureSession(sessionId);
+            store().patchMeta(sessionId, _objectSpread(_objectSpread({
+              placeholderId: placeholderId,
+              error: null,
+              isLoading: true,
+              isWriting: false
+            }, agentId != null ? {
+              agentId: agentId
+            } : {}), agentName != null ? {
+              agentName: agentName
+            } : {}));
+            store().setStatus(sessionId, 'thinking');
+            sessionStreamingText.start(sessionId, placeholderId);
+            store().setActivity(sessionId, getInitialStreamActivity(t, activityOptions !== null && activityOptions !== void 0 ? activityOptions : {}));
+            _context2.prev = 3;
+            _context2.next = 4;
+            return maia.Orchestrator.orchestrator(request, controller.signal);
+          case 4:
+            response = _context2.sent;
+            _context2.next = 5;
+            return parseSessionSSE(response, active, params);
+          case 5:
+            _context2.next = 7;
+            break;
+          case 6:
+            _context2.prev = 6;
+            _t4 = _context2["catch"](3);
+            if (!active.isStopped) {
+              sessionStreamingText.clear(sessionId);
+              store().patchMeta(sessionId, {
+                isLoading: false,
+                isWriting: false
+              });
+              store().setActivity(sessionId, null);
+              store().setStatus(sessionId, 'error');
+              (_callbacks$onError2 = callbacks.onError) === null || _callbacks$onError2 === void 0 || _callbacks$onError2.call(callbacks);
+            }
+          case 7:
+            _context2.prev = 7;
+            activeStreams["delete"](sessionId);
+            return _context2.finish(7);
+          case 8:
+            return _context2.abrupt("return", {
+              started: true
+            });
+          case 9:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, null, [[3, 6, 7, 8]]);
+    }))();
+  },
+  /** Resume HITL (`continue-thread`) keyed por sessionId — mismo motor que orchestrator. */startContinueStream: function startContinueStream(params) {
+    return _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var _ref2;
+      var sessionId, placeholderId, continueRequest, callbacks, t, hitlExecutionContext, agentId, agentName, controller, active, sseParams, response, _callbacks$onError3, _t5;
+      return _regeneratorRuntime.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            ensureSessionNotificationsInitialized();
+            sessionId = params.sessionId, placeholderId = params.placeholderId, continueRequest = params.continueRequest, callbacks = params.callbacks, t = params.t, hitlExecutionContext = params.hitlExecutionContext, agentId = params.agentId, agentName = params.agentName;
+            if (!isStreamActive(sessionId)) {
+              _context3.next = 1;
+              break;
+            }
+            return _context3.abrupt("return", {
+              started: false,
+              reason: 'already_active'
+            });
+          case 1:
+            if (!(getActiveStreamCount() >= MAX_CONCURRENT_STREAMS)) {
+              _context3.next = 2;
+              break;
+            }
+            return _context3.abrupt("return", {
+              started: false,
+              reason: 'limit'
+            });
+          case 2:
+            if (hitlExecutionContext) {
+              sessionHitlContext.set(sessionId, hitlExecutionContext);
+            }
+            controller = new AbortController();
+            active = {
+              sessionId: sessionId,
+              controller: controller,
+              isStopped: false
+            };
+            activeStreams.set(sessionId, active);
+            store().ensureSession(sessionId);
+            store().patchMeta(sessionId, _objectSpread(_objectSpread({
+              placeholderId: placeholderId,
+              error: null,
+              isLoading: true,
+              isWriting: false
+            }, agentId != null ? {
+              agentId: agentId
+            } : {}), agentName != null ? {
+              agentName: agentName
+            } : {}));
+            store().setStatus(sessionId, 'thinking');
+            sessionStreamingText.start(sessionId, placeholderId);
+            store().setActivity(sessionId, resolveInitialHitlStreamActivity(t, (_ref2 = hitlExecutionContext !== null && hitlExecutionContext !== void 0 ? hitlExecutionContext : sessionHitlContext.get(sessionId)) !== null && _ref2 !== void 0 ? _ref2 : undefined));
+            sseParams = {
+              sessionId: sessionId,
+              placeholderId: placeholderId,
+              request: {},
+              callbacks: callbacks,
+              t: t,
+              hitlExecutionContext: hitlExecutionContext !== null && hitlExecutionContext !== void 0 ? hitlExecutionContext : sessionHitlContext.get(sessionId),
+              agentId: agentId,
+              agentName: agentName,
+              sidebarOnFirstToken: false
+            };
+            _context3.prev = 3;
+            _context3.next = 4;
+            return maia.Orchestrator.continueThread(continueRequest, controller.signal);
+          case 4:
+            response = _context3.sent;
+            if (response.ok) {
+              _context3.next = 5;
+              break;
+            }
+            throw new Error("continue-thread failed: ".concat(response.status));
+          case 5:
+            _context3.next = 6;
+            return parseSessionSSE(response, active, sseParams);
+          case 6:
+            _context3.next = 8;
+            break;
+          case 7:
+            _context3.prev = 7;
+            _t5 = _context3["catch"](3);
+            if (!active.isStopped) {
+              sessionStreamingText.clear(sessionId);
+              store().patchMeta(sessionId, {
+                isLoading: false,
+                isWriting: false
+              });
+              store().setActivity(sessionId, null);
+              store().setStatus(sessionId, 'error');
+              (_callbacks$onError3 = callbacks.onError) === null || _callbacks$onError3 === void 0 || _callbacks$onError3.call(callbacks);
+            }
+          case 8:
+            _context3.prev = 8;
+            activeStreams["delete"](sessionId);
+            sessionHitlContext.clear(sessionId);
+            return _context3.finish(8);
+          case 9:
+            return _context3.abrupt("return", {
+              started: true
+            });
+          case 10:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, null, [[3, 7, 8, 9]]);
+    }))();
+  },
+  /** Cancelación explícita del usuario (mensaje "cancelado"). */stopStream: function stopStream(sessionId, callbacks) {
+    var _callbacks$onStop;
+    var active = activeStreams.get(sessionId);
+    if (!active) return;
+    active.isStopped = true;
+    active.controller.abort();
+    activeStreams["delete"](sessionId);
+    sessionStreamingText.clear(sessionId);
+    store().patchMeta(sessionId, {
+      isLoading: false,
+      isWriting: false
+    });
+    store().setActivity(sessionId, null);
+    store().setStatus(sessionId, 'cancelled');
+    callbacks === null || callbacks === void 0 || (_callbacks$onStop = callbacks.onStop) === null || _callbacks$onStop === void 0 || _callbacks$onStop.call(callbacks);
+  },
+  /** Aborta sin marcar "cancelado" (uso interno / limpieza). */abortSilently: function abortSilently(sessionId) {
+    var _store$getMeta;
+    var active = activeStreams.get(sessionId);
+    if (!active) return;
+    active.isStopped = true;
+    active.controller.abort();
+    activeStreams["delete"](sessionId);
+    sessionStreamingText.clear(sessionId);
+    store().patchMeta(sessionId, {
+      isLoading: false,
+      isWriting: false
+    });
+    store().setActivity(sessionId, null);
+    if (((_store$getMeta = store().getMeta(sessionId)) === null || _store$getMeta === void 0 ? void 0 : _store$getMeta.status) !== 'complete') {
+      store().setStatus(sessionId, 'idle');
+    }
+  },
+  abortAll: function abortAll() {
+    var _this = this;
+    Array.from(activeStreams.keys()).forEach(function (sessionId) {
+      return _this.abortSilently(sessionId);
+    });
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["maia","getInitialStreamActivity","getThinkingLoadingMessage","getWritingStreamActivity","resolveHitlNodeStreamActivity","resolveInitialHitlStreamActivity","isCompleteLikeSsePayload","mergeStreamChunk","sessionStreamingText","useSessionsStore","ensureSessionNotificationsInitialized","ensureSessionInSidebarFromRequest","sessionHitlContext","MAX_CONCURRENT_STREAMS","STREAM_THROTTLE_MS","activeStreams","Map","store","getState","isStreamActive","sessionId","has","getActiveStreamCount","size","parseSessionSSE","_ref","_asyncToGenerator","_regeneratorRuntime","mark","_callee","response","active","params","_params$hitlExecution","_response$body","_data$error","_data$error2","_callbacks$onError","_data$error3","_data$error4","placeholderId","callbacks","t","hitlExecutionContext","pendingContent","throttleTimer","flushToStores","emitThrottled","flushPending","reader","decoder","buffer","accumulatedContent","hasStartedWriting","hasAddedToSidebar","maybeAddSessionToSidebar","ensureWritingStarted","applyStreamChunk","applyStreamComplete","_yield$reader$read","done","value","lines","_iterator","_step","line","_line$split","_line$split2","eventLine","dataLine","eventType","dataStr","data","chunk","_chunk","_callbacks$onApproval","isManualApproval","_t","_t2","_t3","wrap","_context","prev","next","get","content","_callbacks$onStreamUp","setText","onStreamUpdate","call","window","setTimeout","toEmit","clearTimeout","body","getReader","Error","TextDecoder","sidebarOnFirstToken","request","agentEmoji","_callbacks$onStartWri","patchMeta","isLoading","isWriting","setStatus","setActivity","onStartWriting","payload","_payload$agent_id","_subagentRaw$resolved","_callbacks$onFinishSt","finalContent","sources","memorySessionId","memory_session_id","attachments","Array","isArray","suggestions","suggest_reply","agentIdRaw","agent_id","agentId","completedAgentId","String","trim","subagentRaw","subagent","resolvedContext","resolved_context","clear","finishPayload","onFinishStream","isStopped","cancel","abrupt","read","sent","decode","stream","split","pop","_createForOfIteratorHelper","s","n","_slicedToArray","replace","JSON","parse","phase","message","node","undefined","thread_id","manual_approval_detected","onApprovalRequired","pending_actions","length","console","error","setError","type","onError","warn","e","f","finish","stop","_x","_x2","_x3","apply","arguments","sessionStreamManager","isActive","getActiveCount","getActiveSessionIds","from","keys","startStream","_callee2","activityOptions","agentName","controller","_callbacks$onError2","_t4","_context2","started","reason","AbortController","set","ensureSession","_objectSpread","start","Orchestrator","orchestrator","signal","startContinueStream","_callee3","_ref2","continueRequest","sseParams","_callbacks$onError3","_t5","_context3","continueThread","ok","concat","status","stopStream","_callbacks$onStop","abort","onStop","abortSilently","_store$getMeta","getMeta","abortAll","_this","forEach"],"sources":["../../../src/store/sessions/sessionStreamManager.ts"],"sourcesContent":["/* eslint-disable no-console */\n/* eslint-disable no-continue */\n/* eslint-disable no-await-in-loop */\n/* eslint-disable no-restricted-syntax */\n/* eslint-disable no-constant-condition */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport maia from '../../services/maia'\nimport type { ApprovalRequest } from '../../types/Chat'\nimport {\n  getInitialStreamActivity,\n  getThinkingLoadingMessage,\n  getWritingStreamActivity,\n  resolveHitlNodeStreamActivity,\n  resolveInitialHitlStreamActivity,\n} from '../../utils/streamActivityMessages'\nimport type { HitlExecutionContext } from '../../utils/streamActivityMessages'\nimport { isCompleteLikeSsePayload, mergeStreamChunk } from '../../utils/sseStreamContent'\nimport { sessionStreamingText } from './sessionStreamingText'\nimport { useSessionsStore } from './useSessionsStore'\nimport { ensureSessionNotificationsInitialized } from './sessionNotifications'\nimport { ensureSessionInSidebarFromRequest } from '../chatsSidebarOptimistic'\nimport { sessionHitlContext } from './sessionHitlContext'\nimport type { SessionFinishPayload, SessionStreamCallbacks, StartStreamResult } from './sessions.types'\n\ntype OrchestratorRequest = Parameters<typeof maia.Orchestrator.orchestrator>[0]\ntype ContinueThreadRequest = Parameters<typeof maia.Orchestrator.continueThread>[0]\n\n/** Compatible con el `t` de i18next (uso de una sola key). */\ntype TranslateFn = (key: string) => string\n\ntype StartStreamParams = {\n  sessionId: string\n  placeholderId: string\n  request: OrchestratorRequest\n  callbacks: SessionStreamCallbacks\n  t: TranslateFn\n  activityOptions?: {\n    isWebSearchActive?: boolean\n    isDeepSearchActive?: boolean\n    hasAttachments?: boolean\n    attachmentsCount?: number\n  }\n  hitlExecutionContext?: HitlExecutionContext | null\n  agentId?: string | number\n  agentName?: string\n  /** Si false, no agrega la sesión al sidebar al primer token (p. ej. continue-thread). */\n  sidebarOnFirstToken?: boolean\n  agentEmoji?: string | null\n}\n\ntype StartContinueStreamParams = {\n  sessionId: string\n  placeholderId: string\n  continueRequest: ContinueThreadRequest\n  callbacks: SessionStreamCallbacks\n  t: TranslateFn\n  hitlExecutionContext?: HitlExecutionContext | null\n  agentId?: string | number\n  agentName?: string\n}\n\ntype ActiveStream = {\n  sessionId: string\n  controller: AbortController\n  isStopped: boolean\n}\n\n/**\n * Máximo de sesiones generando en paralelo. Protege red/recursos del cliente.\n * Ajustable a futuro vía flag del host.\n */\nexport const MAX_CONCURRENT_STREAMS = 4\n\nconst STREAM_THROTTLE_MS = 16\n\nconst activeStreams = new Map<string, ActiveStream>()\n\nconst store = () => useSessionsStore.getState()\n\nconst isStreamActive = (sessionId: string): boolean => activeStreams.has(sessionId)\n\nconst getActiveStreamCount = (): number => activeStreams.size\n\nconst parseSessionSSE = async (response: Response, active: ActiveStream, params: StartStreamParams): Promise<void> => {\n  const { sessionId, placeholderId, callbacks, t } = params\n  const hitlExecutionContext = params.hitlExecutionContext ?? sessionHitlContext.get(sessionId)\n\n  let pendingContent: string | null = null\n  let throttleTimer: number | null = null\n\n  const flushToStores = (content: string) => {\n    sessionStreamingText.setText(sessionId, placeholderId, content)\n    callbacks.onStreamUpdate?.(content)\n  }\n\n  const emitThrottled = (content: string) => {\n    pendingContent = content\n    if (throttleTimer != null) return\n    throttleTimer = window.setTimeout(() => {\n      throttleTimer = null\n      if (pendingContent != null) {\n        const toEmit = pendingContent\n        pendingContent = null\n        flushToStores(toEmit)\n      }\n    }, STREAM_THROTTLE_MS)\n  }\n\n  const flushPending = () => {\n    if (throttleTimer != null) {\n      window.clearTimeout(throttleTimer)\n      throttleTimer = null\n    }\n    if (pendingContent != null) {\n      const toEmit = pendingContent\n      pendingContent = null\n      flushToStores(toEmit)\n    }\n  }\n\n  const reader = response.body?.getReader()\n  if (!reader) {\n    throw new Error('No reader available')\n  }\n\n  const decoder = new TextDecoder()\n  let buffer = ''\n  let accumulatedContent = ''\n  let hasStartedWriting = false\n  let hasAddedToSidebar = false\n\n  const maybeAddSessionToSidebar = () => {\n    if (hasAddedToSidebar || params.sidebarOnFirstToken === false) return\n    hasAddedToSidebar = true\n    ensureSessionInSidebarFromRequest(sessionId, params.request, params.agentEmoji)\n  }\n\n  const ensureWritingStarted = () => {\n    if (hasStartedWriting) return\n    hasStartedWriting = true\n    store().patchMeta(sessionId, { isLoading: true, isWriting: true })\n    store().setStatus(sessionId, 'writing')\n    store().setActivity(sessionId, getWritingStreamActivity(t))\n    callbacks.onStartWriting?.()\n  }\n\n  const applyStreamChunk = (chunk: string) => {\n    if (!chunk) return\n    accumulatedContent = mergeStreamChunk(accumulatedContent, chunk)\n    emitThrottled(accumulatedContent)\n  }\n\n  const applyStreamComplete = (payload: Record<string, unknown>) => {\n    const finalContent = (payload.content as string) || accumulatedContent\n    const sources = payload.sources || null\n    const memorySessionId = (payload.memory_session_id as string) || ''\n    const attachments = Array.isArray(payload.attachments) ? payload.attachments : null\n    let suggestions: string[] | null = null\n    if (Array.isArray(payload.suggest_reply)) {\n      suggestions = payload.suggest_reply as string[]\n    } else if (Array.isArray(payload.suggestions)) {\n      suggestions = payload.suggestions as string[]\n    }\n    const agentIdRaw = payload.agent_id ?? payload.agentId\n    const completedAgentId = agentIdRaw != null && String(agentIdRaw).trim() !== '' ? String(agentIdRaw).trim() : null\n    const subagentRaw = payload.subagent as { resolved_context?: unknown } | null | undefined\n    const resolvedContext = subagentRaw?.resolved_context ?? null\n\n    flushPending()\n    sessionStreamingText.clear(sessionId)\n    store().patchMeta(sessionId, { isLoading: false, isWriting: false })\n    store().setActivity(sessionId, null)\n    store().setStatus(sessionId, 'complete')\n\n    const finishPayload: SessionFinishPayload = {\n      content: finalContent,\n      sources,\n      memorySessionId,\n      attachments,\n      suggestions,\n      completedAgentId,\n      resolvedContext,\n    }\n    callbacks.onFinishStream?.(finishPayload)\n  }\n\n  try {\n    while (true) {\n      if (active.isStopped) {\n        reader.cancel()\n        break\n      }\n\n      const { done, value } = await reader.read()\n      if (done) break\n\n      if (active.isStopped) {\n        reader.cancel()\n        break\n      }\n\n      buffer += decoder.decode(value, { stream: true })\n      const lines = buffer.split('\\n\\n')\n      buffer = lines.pop() || ''\n\n      for (const line of lines) {\n        if (line.trim() === '') continue\n\n        const [eventLine, dataLine] = line.split('\\n')\n        if (!eventLine || !dataLine) continue\n\n        const eventType = eventLine.replace('event: ', '').trim()\n        const dataStr = dataLine.replace('data: ', '').trim()\n\n        try {\n          const data = JSON.parse(dataStr)\n\n          switch (eventType) {\n            case 'thinking':\n              if (!hasStartedWriting) {\n                store().patchMeta(sessionId, { isLoading: true })\n                store().setStatus(sessionId, 'thinking')\n                store().setActivity(sessionId, { phase: 'thinking', message: getThinkingLoadingMessage(0, t) })\n              }\n              break\n\n            case 'token': {\n              const chunk = typeof data.content === 'string' ? data.content : ''\n              maybeAddSessionToSidebar()\n              ensureWritingStarted()\n              applyStreamChunk(chunk)\n              break\n            }\n\n            case 'content': {\n              const chunk = typeof data.content === 'string' ? data.content : ''\n              ensureWritingStarted()\n              applyStreamChunk(chunk)\n              if (isCompleteLikeSsePayload(data)) {\n                applyStreamComplete(data)\n              }\n              break\n            }\n\n            case 'node':\n              if (data.node === 'agent_transfer') {\n                store().patchMeta(sessionId, { isLoading: true })\n                store().setStatus(sessionId, 'thinking')\n              } else if (data.message && typeof data.message === 'string') {\n                store().patchMeta(sessionId, { isLoading: true })\n                store().setStatus(sessionId, 'thinking')\n                store().setActivity(\n                  sessionId,\n                  resolveHitlNodeStreamActivity(\n                    data.message,\n                    t,\n                    hitlExecutionContext ?? undefined,\n                    typeof data.thread_id === 'string' ? data.thread_id : undefined\n                  )\n                )\n              }\n              break\n\n            case 'complete':\n              applyStreamComplete(data)\n              break\n\n            case 'approval_required': {\n              flushPending()\n              const isManualApproval = data.manual_approval_detected === true\n              store().patchMeta(sessionId, { isWriting: false })\n              if (!isManualApproval) {\n                store().patchMeta(sessionId, { isLoading: false })\n                sessionStreamingText.clear(sessionId)\n                store().setActivity(sessionId, null)\n              }\n              store().setStatus(sessionId, 'awaiting_approval')\n              callbacks.onApprovalRequired?.(data as ApprovalRequest, accumulatedContent)\n              if (isManualApproval && Array.isArray(data.pending_actions) && data.pending_actions.length > 0) {\n                store().patchMeta(sessionId, { isLoading: true })\n                store().setStatus(sessionId, 'thinking')\n                store().setActivity(sessionId, resolveInitialHitlStreamActivity(t, hitlExecutionContext ?? undefined))\n              }\n              break\n            }\n\n            case 'error':\n              console.error('SSE Error:', data.error)\n              flushPending()\n              sessionStreamingText.clear(sessionId)\n              store().patchMeta(sessionId, { isLoading: false, isWriting: false })\n              store().setActivity(sessionId, null)\n              store().setError(sessionId, { type: data.error?.type, message: data.error?.message })\n              store().setStatus(sessionId, 'error')\n              callbacks.onError?.(data.error?.type, data.error?.message)\n              break\n\n            default:\n              console.warn('Unknown SSE event type:', eventType)\n              break\n          }\n        } catch (parseError) {\n          console.error('Error parsing SSE data:', parseError, dataStr)\n        }\n      }\n    }\n  } finally {\n    flushPending()\n  }\n}\n\n/**\n * Manager singleton (module-level) que corre N streams del orchestrator en\n * paralelo, uno por `sessionId`. Sobrevive a cambios de vista y al cierre del\n * modal: los streams solo se cancelan con stop explícito del usuario o al\n * completar/errorar.\n */\nexport const sessionStreamManager = {\n  isActive: isStreamActive,\n  getActiveCount: getActiveStreamCount,\n  getActiveSessionIds: (): string[] => Array.from(activeStreams.keys()),\n\n  async startStream(params: StartStreamParams): Promise<StartStreamResult> {\n    ensureSessionNotificationsInitialized()\n\n    const { sessionId, placeholderId, request, callbacks, t, activityOptions, agentId, agentName } = params\n\n    if (isStreamActive(sessionId)) {\n      return { started: false, reason: 'already_active' }\n    }\n    if (getActiveStreamCount() >= MAX_CONCURRENT_STREAMS) {\n      return { started: false, reason: 'limit' }\n    }\n\n    const controller = new AbortController()\n    const active: ActiveStream = { sessionId, controller, isStopped: false }\n    activeStreams.set(sessionId, active)\n\n    store().ensureSession(sessionId)\n    store().patchMeta(sessionId, {\n      placeholderId,\n      error: null,\n      isLoading: true,\n      isWriting: false,\n      ...(agentId != null ? { agentId } : {}),\n      ...(agentName != null ? { agentName } : {}),\n    })\n    store().setStatus(sessionId, 'thinking')\n    sessionStreamingText.start(sessionId, placeholderId)\n    store().setActivity(sessionId, getInitialStreamActivity(t, activityOptions ?? {}))\n\n    try {\n      const response = await maia.Orchestrator.orchestrator(request, controller.signal)\n      await parseSessionSSE(response, active, params)\n    } catch (error) {\n      if (!active.isStopped) {\n        sessionStreamingText.clear(sessionId)\n        store().patchMeta(sessionId, { isLoading: false, isWriting: false })\n        store().setActivity(sessionId, null)\n        store().setStatus(sessionId, 'error')\n        callbacks.onError?.()\n      }\n    } finally {\n      activeStreams.delete(sessionId)\n    }\n\n    return { started: true }\n  },\n\n  /** Resume HITL (`continue-thread`) keyed por sessionId — mismo motor que orchestrator. */\n  async startContinueStream(params: StartContinueStreamParams): Promise<StartStreamResult> {\n    ensureSessionNotificationsInitialized()\n\n    const { sessionId, placeholderId, continueRequest, callbacks, t, hitlExecutionContext, agentId, agentName } = params\n\n    if (isStreamActive(sessionId)) {\n      return { started: false, reason: 'already_active' }\n    }\n    if (getActiveStreamCount() >= MAX_CONCURRENT_STREAMS) {\n      return { started: false, reason: 'limit' }\n    }\n\n    if (hitlExecutionContext) {\n      sessionHitlContext.set(sessionId, hitlExecutionContext)\n    }\n\n    const controller = new AbortController()\n    const active: ActiveStream = { sessionId, controller, isStopped: false }\n    activeStreams.set(sessionId, active)\n\n    store().ensureSession(sessionId)\n    store().patchMeta(sessionId, {\n      placeholderId,\n      error: null,\n      isLoading: true,\n      isWriting: false,\n      ...(agentId != null ? { agentId } : {}),\n      ...(agentName != null ? { agentName } : {}),\n    })\n    store().setStatus(sessionId, 'thinking')\n    sessionStreamingText.start(sessionId, placeholderId)\n    store().setActivity(\n      sessionId,\n      resolveInitialHitlStreamActivity(t, hitlExecutionContext ?? sessionHitlContext.get(sessionId) ?? undefined)\n    )\n\n    const sseParams: StartStreamParams = {\n      sessionId,\n      placeholderId,\n      request: {} as OrchestratorRequest,\n      callbacks,\n      t,\n      hitlExecutionContext: hitlExecutionContext ?? sessionHitlContext.get(sessionId),\n      agentId,\n      agentName,\n      sidebarOnFirstToken: false,\n    }\n\n    try {\n      const response = await maia.Orchestrator.continueThread(continueRequest, controller.signal)\n      if (!response.ok) {\n        throw new Error(`continue-thread failed: ${response.status}`)\n      }\n      await parseSessionSSE(response, active, sseParams)\n    } catch (error) {\n      if (!active.isStopped) {\n        sessionStreamingText.clear(sessionId)\n        store().patchMeta(sessionId, { isLoading: false, isWriting: false })\n        store().setActivity(sessionId, null)\n        store().setStatus(sessionId, 'error')\n        callbacks.onError?.()\n      }\n    } finally {\n      activeStreams.delete(sessionId)\n      sessionHitlContext.clear(sessionId)\n    }\n\n    return { started: true }\n  },\n\n  /** Cancelación explícita del usuario (mensaje \"cancelado\"). */\n  stopStream(sessionId: string, callbacks?: SessionStreamCallbacks) {\n    const active = activeStreams.get(sessionId)\n    if (!active) return\n    active.isStopped = true\n    active.controller.abort()\n    activeStreams.delete(sessionId)\n    sessionStreamingText.clear(sessionId)\n    store().patchMeta(sessionId, { isLoading: false, isWriting: false })\n    store().setActivity(sessionId, null)\n    store().setStatus(sessionId, 'cancelled')\n    callbacks?.onStop?.()\n  },\n\n  /** Aborta sin marcar \"cancelado\" (uso interno / limpieza). */\n  abortSilently(sessionId: string) {\n    const active = activeStreams.get(sessionId)\n    if (!active) return\n    active.isStopped = true\n    active.controller.abort()\n    activeStreams.delete(sessionId)\n    sessionStreamingText.clear(sessionId)\n    store().patchMeta(sessionId, { isLoading: false, isWriting: false })\n    store().setActivity(sessionId, null)\n    if (store().getMeta(sessionId)?.status !== 'complete') {\n      store().setStatus(sessionId, 'idle')\n    }\n  },\n\n  abortAll() {\n    Array.from(activeStreams.keys()).forEach(sessionId => this.abortSilently(sessionId))\n  },\n}\n"],"mappings":"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","ignoreList":[]}