@projectcor/maia-components 2.49.0-beta.1 → 2.49.1-0

package/lib/hooks/useAgentModel/useAgentModel.spec.js

@@ -0,0 +1,83 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook } from '@testing-library/react';
+import { useAgentModel } from './useAgentModel';
+var handleGetAgentModels = jest.fn();
+var models = [{
+  id: 1,
+  display_name: 'Default',
+  model_name: 'gpt-4'
+}, {
+  id: 2,
+  display_name: 'Alt',
+  model_name: 'gpt-3.5'
+}];
+jest.mock('../../services/maia/Agents/getAgentModels', function () {
+  return {
+    useGetAgentModels: function useGetAgentModels() {
+      return {
+        agentModels: models,
+        loading: false,
+        error: null,
+        handleGetAgentModels: handleGetAgentModels
+      };
+    }
+  };
+});
+describe('useAgentModel', function () {
+  beforeEach(function () {
+    handleGetAgentModels.mockReset();
+    handleGetAgentModels.mockResolvedValue(undefined);
+  });
+  it('finds a model by id', function () {
+    var _result$current$getAg;
+    var _renderHook = renderHook(function () {
+        return useAgentModel();
+      }),
+      result = _renderHook.result;
+    expect((_result$current$getAg = result.current.getAgentModelById(2)) === null || _result$current$getAg === void 0 ? void 0 : _result$current$getAg.display_name).toBe('Alt');
+    expect(result.current.getAgentModelById(99)).toBeUndefined();
+  });
+  it('returns id 1 as default when present', function () {
+    var _result$current$getDe;
+    var _renderHook2 = renderHook(function () {
+        return useAgentModel();
+      }),
+      result = _renderHook2.result;
+    expect((_result$current$getDe = result.current.getDefaultAgentModel()) === null || _result$current$getDe === void 0 ? void 0 : _result$current$getDe.id).toBe(1);
+  });
+  it('loads models through the underlying fetch hook', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _renderHook3, result, loaded;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _renderHook3 = renderHook(function () {
+            return useAgentModel();
+          }), result = _renderHook3.result;
+          loaded = [];
+          _context2.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+            return _regeneratorRuntime.wrap(function (_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 1;
+                  return result.current.getAllAgentModels();
+                case 1:
+                  loaded = _context.sent;
+                case 2:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+        case 1:
+          expect(handleGetAgentModels).toHaveBeenCalled();
+          expect(loaded).toEqual(models);
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useAgentModel/useCreateAgent.helpers.js

@@ -0,0 +1,144 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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 { buildAgentConnectorsFromCorAccess, buildAgentToolGroupsRequest, DEFAULT_COR_ACCESS } from '../../utils/normalizeAgentConnectors';
+import { hasMaiaExternalConnectorsAccess } from '../../constants/maiaExternalConnectorsAccess';
+export var parsedValuesByReq = function parsedValuesByReq(agentValues) {
+  var _agentValues$aiModel$, _agentValues$aiModel, _agentValues$aiModel$2, _agentValues$aiModel2;
+  return {
+    name: agentValues.name,
+    emoji: agentValues.emoji || '✨',
+    introduction: agentValues.introduction || '',
+    input_placeholder: agentValues.inputPlaceholder || '',
+    user_prompt: agentValues.userPrompt,
+    provider: (_agentValues$aiModel$ = (_agentValues$aiModel = agentValues.aiModel) === null || _agentValues$aiModel === void 0 ? void 0 : _agentValues$aiModel.provider) !== null && _agentValues$aiModel$ !== void 0 ? _agentValues$aiModel$ : '',
+    model_name: (_agentValues$aiModel$2 = (_agentValues$aiModel2 = agentValues.aiModel) === null || _agentValues$aiModel2 === void 0 ? void 0 : _agentValues$aiModel2.model_name) !== null && _agentValues$aiModel$2 !== void 0 ? _agentValues$aiModel$2 : ''
+  };
+};
+export var resolveCreateAgentCorAccess = function resolveCreateAgentCorAccess(accessibility) {
+  var _ref;
+  return (_ref = accessibility === null || accessibility === void 0 ? void 0 : accessibility.corAccess) !== null && _ref !== void 0 ? _ref : DEFAULT_COR_ACCESS;
+};
+export var resolveCreateAgentSelectedConnectors = function resolveCreateAgentSelectedConnectors(externalConnectorsEnabled, accessibility) {
+  return externalConnectorsEnabled ? (accessibility === null || accessibility === void 0 ? void 0 : accessibility.selectedConnectors) || [] : [];
+};
+export var shouldOpenConnectorAuthPopup = function shouldOpenConnectorAuthPopup(externalConnectorsEnabled, selectedConnectors) {
+  return externalConnectorsEnabled && selectedConnectors.length > 0;
+};
+export var resolveConnectorAuthErrorText = function resolveConnectorAuthErrorText(authErrors, translateNetsuite, formatConnectorError) {
+  return authErrors.map(function (connectorError) {
+    return connectorError.slug === 'netsuite' ? translateNetsuite : formatConnectorError(connectorError);
+  }).join(' ');
+};
+export var resolveConnectorAuthIncompleteMessage = function resolveConnectorAuthIncompleteMessage(authorizedSlugs, authError, timeoutMessage) {
+  if (authorizedSlugs.length) {
+    return null;
+  }
+  return authError && authError !== 'timeout' ? authError : timeoutMessage;
+};
+export var buildCreateAgentSuccessPayload = function buildCreateAgentSuccessPayload(response, corAccess, selectedConnectors) {
+  return _objectSpread(_objectSpread({}, response), {}, {
+    connectors: buildAgentConnectorsFromCorAccess(corAccess, selectedConnectors)
+  });
+};
+export var resolveCreateAgentSideEffectFlags = function resolveCreateAgentSideEffectFlags() {
+  return {
+    externalConnectorsEnabled: hasMaiaExternalConnectorsAccess(),
+    toolGroupsPayload: function toolGroupsPayload(corAccess) {
+      return buildAgentToolGroupsRequest(corAccess);
+    }
+  };
+};
+export var shouldCloseConnectorAuthPopup = function shouldCloseConnectorAuthPopup(authPopup, closed) {
+  return Boolean(authPopup && !closed);
+};
+export var shouldRunCreateAgentSideEffects = function shouldRunCreateAgentSideEffects(response) {
+  return Boolean(response === null || response === void 0 ? void 0 : response.id);
+};
+export var executeCreateAgentSideEffects = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(response, corAccess, selectedConnectors, externalConnectorsEnabled, deps, translate) {
+    var agentId, _resolveCreateAgentSi, toolGroupsPayload, authPopup, connectorsResponse, pendingAuth, authPopupWindow, authErrors, _yield$deps$waitForCo, authorized, authError, incompleteMessage, _t, _t2;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (shouldRunCreateAgentSideEffects(response)) {
+            _context.next = 1;
+            break;
+          }
+          return _context.abrupt("return");
+        case 1:
+          agentId = response.id.toString();
+          _resolveCreateAgentSi = resolveCreateAgentSideEffectFlags(), toolGroupsPayload = _resolveCreateAgentSi.toolGroupsPayload;
+          _context.prev = 2;
+          _context.next = 3;
+          return deps.setAgentToolGroups(agentId, toolGroupsPayload(corAccess));
+        case 3:
+          _context.next = 5;
+          break;
+        case 4:
+          _context.prev = 4;
+          _t = _context["catch"](2);
+          console.error('Error setting agent tool groups:', _t);
+        case 5:
+          if (externalConnectorsEnabled) {
+            _context.next = 6;
+            break;
+          }
+          return _context.abrupt("return");
+        case 6:
+          authPopup = shouldOpenConnectorAuthPopup(externalConnectorsEnabled, selectedConnectors) ? deps.openAuthPopup() : null;
+          _context.prev = 7;
+          _context.next = 8;
+          return deps.saveAgentConnectors(agentId, selectedConnectors);
+        case 8:
+          connectorsResponse = _context.sent;
+          pendingAuth = connectorsResponse.requires_auth || [];
+          authPopupWindow = deps.openConnectorAuthorizationWindows(pendingAuth, authPopup);
+          authErrors = connectorsResponse.auth_errors || [];
+          if (authErrors.length) {
+            deps.onConnectorAuthError(resolveConnectorAuthErrorText(authErrors, translate('accessibilitySection.netsuiteAuthSetupRequired'), deps.connectorAuthErrorMessage));
+          }
+          if (!pendingAuth.length) {
+            _context.next = 10;
+            break;
+          }
+          _context.next = 9;
+          return deps.waitForConnectorAuthorization({
+            agentId: agentId,
+            slugs: pendingAuth.map(function (item) {
+              return item.slug;
+            }),
+            popup: authPopupWindow
+          });
+        case 9:
+          _yield$deps$waitForCo = _context.sent;
+          authorized = _yield$deps$waitForCo.authorized;
+          authError = _yield$deps$waitForCo.error;
+          incompleteMessage = resolveConnectorAuthIncompleteMessage(authorized, authError, translate('accessibilitySection.connectorAuthIncomplete'));
+          if (incompleteMessage) {
+            deps.onConnectorAuthError(incompleteMessage);
+          }
+        case 10:
+          _context.next = 12;
+          break;
+        case 11:
+          _context.prev = 11;
+          _t2 = _context["catch"](7);
+          console.error('Error setting agent connectors:', _t2);
+          if (shouldCloseConnectorAuthPopup(authPopup)) {
+            deps.closeAuthPopup(authPopup);
+          }
+          deps.onConnectorSetupFailed();
+        case 12:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[2, 4], [7, 11]]);
+  }));
+  return function executeCreateAgentSideEffects(_x, _x2, _x3, _x4, _x5, _x6) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["buildAgentConnectorsFromCorAccess","buildAgentToolGroupsRequest","DEFAULT_COR_ACCESS","hasMaiaExternalConnectorsAccess","parsedValuesByReq","agentValues","_agentValues$aiModel$","_agentValues$aiModel","_agentValues$aiModel$2","_agentValues$aiModel2","name","emoji","introduction","input_placeholder","inputPlaceholder","user_prompt","userPrompt","provider","aiModel","model_name","resolveCreateAgentCorAccess","accessibility","_ref","corAccess","resolveCreateAgentSelectedConnectors","externalConnectorsEnabled","selectedConnectors","shouldOpenConnectorAuthPopup","length","resolveConnectorAuthErrorText","authErrors","translateNetsuite","formatConnectorError","map","connectorError","slug","join","resolveConnectorAuthIncompleteMessage","authorizedSlugs","authError","timeoutMessage","buildCreateAgentSuccessPayload","response","_objectSpread","connectors","resolveCreateAgentSideEffectFlags","toolGroupsPayload","shouldCloseConnectorAuthPopup","authPopup","closed","Boolean","shouldRunCreateAgentSideEffects","id","executeCreateAgentSideEffects","_ref2","_asyncToGenerator","_regeneratorRuntime","mark","_callee","deps","translate","agentId","_resolveCreateAgentSi","connectorsResponse","pendingAuth","authPopupWindow","_yield$deps$waitForCo","authorized","incompleteMessage","_t","_t2","wrap","_context","prev","next","abrupt","toString","setAgentToolGroups","console","error","openAuthPopup","saveAgentConnectors","sent","requires_auth","openConnectorAuthorizationWindows","auth_errors","onConnectorAuthError","connectorAuthErrorMessage","waitForConnectorAuthorization","slugs","item","popup","closeAuthPopup","onConnectorSetupFailed","stop","_x","_x2","_x3","_x4","_x5","_x6","apply","arguments"],"sources":["../../../src/hooks/useAgentModel/useCreateAgent.helpers.ts"],"sourcesContent":["import type { AgentCreateRequest } from '../../services/maia/Agents/createAgent'\nimport {\n  buildAgentConnectorsFromCorAccess,\n  buildAgentToolGroupsRequest,\n  DEFAULT_COR_ACCESS,\n  type CorAccess,\n} from '../../utils/normalizeAgentConnectors'\nimport { hasMaiaExternalConnectorsAccess } from '../../constants/maiaExternalConnectorsAccess'\nimport type {\n  ConnectorAuthError,\n  PendingConnectorAuthorization,\n  SaveAgentConnectorsResponse,\n} from '../../services/maia/Agents/connectors'\n\nexport type CreateAgentFormValues = {\n  general: {\n    name: string\n    emoji?: string\n    introduction?: string\n    inputPlaceholder?: string\n    userPrompt: string\n    aiModel?: { provider?: string; model_name?: string }\n  }\n  accessibility?: {\n    corAccess?: Record<string, boolean>\n    selectedConnectors?: string[]\n  }\n}\n\nexport const parsedValuesByReq = (agentValues: CreateAgentFormValues['general']): AgentCreateRequest => ({\n  name: agentValues.name,\n  emoji: agentValues.emoji || '✨',\n  introduction: agentValues.introduction || '',\n  input_placeholder: agentValues.inputPlaceholder || '',\n  user_prompt: agentValues.userPrompt,\n  provider: agentValues.aiModel?.provider ?? '',\n  model_name: agentValues.aiModel?.model_name ?? '',\n})\n\nexport const resolveCreateAgentCorAccess = (\n  accessibility: CreateAgentFormValues['accessibility'] | undefined\n): CorAccess => (accessibility?.corAccess as CorAccess | undefined) ?? DEFAULT_COR_ACCESS\n\nexport const resolveCreateAgentSelectedConnectors = (\n  externalConnectorsEnabled: boolean,\n  accessibility: CreateAgentFormValues['accessibility'] | undefined\n): string[] => (externalConnectorsEnabled ? accessibility?.selectedConnectors || [] : [])\n\nexport const shouldOpenConnectorAuthPopup = (\n  externalConnectorsEnabled: boolean,\n  selectedConnectors: string[]\n): boolean => externalConnectorsEnabled && selectedConnectors.length > 0\n\nexport const resolveConnectorAuthErrorText = (\n  authErrors: ConnectorAuthError[],\n  translateNetsuite: string,\n  formatConnectorError: (error: ConnectorAuthError) => string\n): string =>\n  authErrors\n    .map(connectorError =>\n      connectorError.slug === 'netsuite' ? translateNetsuite : formatConnectorError(connectorError)\n    )\n    .join(' ')\n\nexport const resolveConnectorAuthIncompleteMessage = (\n  authorizedSlugs: string[],\n  authError: string | undefined,\n  timeoutMessage: string\n): string | null => {\n  if (authorizedSlugs.length) {\n    return null\n  }\n  return authError && authError !== 'timeout' ? authError : timeoutMessage\n}\n\nexport const buildCreateAgentSuccessPayload = (\n  response: Record<string, unknown>,\n  corAccess: CorAccess,\n  selectedConnectors: string[]\n) => ({\n  ...response,\n  connectors: buildAgentConnectorsFromCorAccess(corAccess, selectedConnectors),\n})\n\nexport const resolveCreateAgentSideEffectFlags = () => ({\n  externalConnectorsEnabled: hasMaiaExternalConnectorsAccess(),\n  toolGroupsPayload: (corAccess: CorAccess) => buildAgentToolGroupsRequest(corAccess),\n})\n\nexport const shouldCloseConnectorAuthPopup = (authPopup: Window | null | undefined, closed?: boolean): boolean =>\n  Boolean(authPopup && !closed)\n\nexport type CreateAgentApiResponse = Record<string, unknown> & { id?: string | number; error?: string }\n\nexport type CreateAgentSideEffectDeps = {\n  setAgentToolGroups: (agentId: string, slugs: string[]) => Promise<unknown>\n  saveAgentConnectors: (agentId: string, connectors: string[]) => Promise<SaveAgentConnectorsResponse>\n  openConnectorAuthorizationWindows: (\n    pendingAuth: PendingConnectorAuthorization[],\n    popup: Window | null\n  ) => Window | null\n  waitForConnectorAuthorization: (input: {\n    agentId: string\n    slugs: string[]\n    popup: Window | null\n  }) => Promise<{ authorized: string[]; error?: string }>\n  connectorAuthErrorMessage: (error: ConnectorAuthError) => string\n  onConnectorAuthError: (message: string) => void\n  onConnectorSetupFailed: () => void\n  openAuthPopup: () => Window | null\n  closeAuthPopup: (popup: Window | null) => void\n}\n\nexport const shouldRunCreateAgentSideEffects = (response: CreateAgentApiResponse): boolean => Boolean(response?.id)\n\nexport const executeCreateAgentSideEffects = async (\n  response: CreateAgentApiResponse,\n  corAccess: CorAccess,\n  selectedConnectors: string[],\n  externalConnectorsEnabled: boolean,\n  deps: CreateAgentSideEffectDeps,\n  translate: (key: string) => string\n): Promise<void> => {\n  if (!shouldRunCreateAgentSideEffects(response)) {\n    return\n  }\n\n  const agentId = response.id!.toString()\n  const { toolGroupsPayload } = resolveCreateAgentSideEffectFlags()\n\n  try {\n    await deps.setAgentToolGroups(agentId, toolGroupsPayload(corAccess))\n  } catch (toolGroupsError) {\n    console.error('Error setting agent tool groups:', toolGroupsError)\n  }\n\n  if (!externalConnectorsEnabled) {\n    return\n  }\n\n  const authPopup = shouldOpenConnectorAuthPopup(externalConnectorsEnabled, selectedConnectors)\n    ? deps.openAuthPopup()\n    : null\n\n  try {\n    const connectorsResponse = await deps.saveAgentConnectors(agentId, selectedConnectors)\n    const pendingAuth = connectorsResponse.requires_auth || []\n    const authPopupWindow = deps.openConnectorAuthorizationWindows(pendingAuth, authPopup)\n    const authErrors = connectorsResponse.auth_errors || []\n\n    if (authErrors.length) {\n      deps.onConnectorAuthError(\n        resolveConnectorAuthErrorText(\n          authErrors,\n          translate('accessibilitySection.netsuiteAuthSetupRequired'),\n          deps.connectorAuthErrorMessage\n        )\n      )\n    }\n\n    if (pendingAuth.length) {\n      const { authorized, error: authError } = await deps.waitForConnectorAuthorization({\n        agentId,\n        slugs: pendingAuth.map(item => item.slug),\n        popup: authPopupWindow,\n      })\n      const incompleteMessage = resolveConnectorAuthIncompleteMessage(\n        authorized,\n        authError,\n        translate('accessibilitySection.connectorAuthIncomplete')\n      )\n      if (incompleteMessage) {\n        deps.onConnectorAuthError(incompleteMessage)\n      }\n    }\n  } catch (connectorsError) {\n    console.error('Error setting agent connectors:', connectorsError)\n    if (shouldCloseConnectorAuthPopup(authPopup)) {\n      deps.closeAuthPopup(authPopup)\n    }\n    deps.onConnectorSetupFailed()\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/hooks/useAgentModel/useCreateAgent.helpers.spec.js

@@ -0,0 +1,268 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { buildCreateAgentSuccessPayload, parsedValuesByReq, resolveConnectorAuthErrorText, resolveConnectorAuthIncompleteMessage, resolveCreateAgentCorAccess, resolveCreateAgentSelectedConnectors, resolveCreateAgentSideEffectFlags, shouldCloseConnectorAuthPopup, shouldOpenConnectorAuthPopup, executeCreateAgentSideEffects, shouldRunCreateAgentSideEffects } from './useCreateAgent.helpers';
+describe('useCreateAgent.helpers', function () {
+  describe('parsedValuesByReq', function () {
+    it('fills defaults for optional general fields', function () {
+      expect(parsedValuesByReq({
+        name: 'Bot',
+        userPrompt: 'Help',
+        aiModel: {
+          provider: 'openai',
+          model_name: 'gpt-4'
+        }
+      })).toEqual({
+        name: 'Bot',
+        emoji: '✨',
+        introduction: '',
+        input_placeholder: '',
+        user_prompt: 'Help',
+        provider: 'openai',
+        model_name: 'gpt-4'
+      });
+    });
+  });
+  describe('connector side effects', function () {
+    it('resolves cor access and selected connectors based on feature flag', function () {
+      expect(resolveCreateAgentCorAccess(undefined)).toEqual({
+        clientes: true,
+        proyectos: true,
+        tareas: true
+      });
+      expect(resolveCreateAgentSelectedConnectors(false, {
+        selectedConnectors: ['slack']
+      })).toEqual([]);
+      expect(resolveCreateAgentSelectedConnectors(true, {
+        selectedConnectors: ['slack']
+      })).toEqual(['slack']);
+      expect(shouldOpenConnectorAuthPopup(true, ['slack'])).toBe(true);
+      expect(shouldOpenConnectorAuthPopup(true, [])).toBe(false);
+    });
+    it('formats connector auth errors and incomplete auth messages', function () {
+      expect(resolveConnectorAuthErrorText([{
+        slug: 'netsuite'
+      }, {
+        slug: 'other',
+        message: 'fail'
+      }], 'Setup netsuite', function (error) {
+        return error.message || 'generic';
+      })).toBe('Setup netsuite fail');
+      expect(resolveConnectorAuthIncompleteMessage(['slack'], undefined, 'timeout msg')).toBeNull();
+      expect(resolveConnectorAuthIncompleteMessage([], 'timeout', 'timeout msg')).toBe('timeout msg');
+      expect(resolveConnectorAuthIncompleteMessage([], 'custom', 'timeout msg')).toBe('custom');
+    });
+    it('builds success payload and popup guards', function () {
+      expect(buildCreateAgentSuccessPayload({
+        id: '1'
+      }, {
+        clientes: true
+      }, ['slack'])).toMatchObject({
+        id: '1',
+        connectors: expect.any(Array)
+      });
+      expect(shouldCloseConnectorAuthPopup({
+        closed: false
+      })).toBe(true);
+      expect(shouldCloseConnectorAuthPopup(null)).toBe(false);
+      expect(resolveCreateAgentSideEffectFlags().toolGroupsPayload({
+        clientes: true
+      })).toEqual(['clientes']);
+    });
+    it('runs side effects for connectors, auth errors and incomplete auth', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var onConnectorAuthError, onConnectorSetupFailed, setAgentToolGroups, saveAgentConnectors, waitForConnectorAuthorization, closeAuthPopup;
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            onConnectorAuthError = jest.fn();
+            onConnectorSetupFailed = jest.fn();
+            setAgentToolGroups = jest.fn().mockResolvedValue(undefined);
+            saveAgentConnectors = jest.fn().mockResolvedValue({
+              requires_auth: [{
+                slug: 'slack'
+              }],
+              auth_errors: [{
+                slug: 'netsuite'
+              }]
+            });
+            waitForConnectorAuthorization = jest.fn().mockResolvedValue({
+              authorized: [],
+              error: 'timeout'
+            });
+            closeAuthPopup = jest.fn();
+            _context.next = 1;
+            return executeCreateAgentSideEffects({
+              id: '9'
+            }, {
+              clientes: true,
+              proyectos: false,
+              tareas: false
+            }, ['slack'], true, {
+              setAgentToolGroups: setAgentToolGroups,
+              saveAgentConnectors: saveAgentConnectors,
+              openConnectorAuthorizationWindows: jest.fn(function () {
+                return null;
+              }),
+              waitForConnectorAuthorization: waitForConnectorAuthorization,
+              connectorAuthErrorMessage: function connectorAuthErrorMessage() {
+                return 'connector error';
+              },
+              onConnectorAuthError: onConnectorAuthError,
+              onConnectorSetupFailed: onConnectorSetupFailed,
+              openAuthPopup: function openAuthPopup() {
+                return {
+                  closed: false
+                };
+              },
+              closeAuthPopup: closeAuthPopup
+            }, function (key) {
+              return key;
+            });
+          case 1:
+            expect(setAgentToolGroups).toHaveBeenCalledWith('9', ['clientes']);
+            expect(onConnectorAuthError).toHaveBeenCalled();
+            expect(onConnectorSetupFailed).not.toHaveBeenCalled();
+            expect(shouldRunCreateAgentSideEffects({
+              id: '1'
+            })).toBe(true);
+            expect(shouldRunCreateAgentSideEffects({})).toBe(false);
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    })));
+    it('skips connector side effects when external connectors are disabled', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+      var saveAgentConnectors;
+      return _regeneratorRuntime.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            saveAgentConnectors = jest.fn();
+            _context2.next = 1;
+            return executeCreateAgentSideEffects({
+              id: '9'
+            }, {
+              clientes: true,
+              proyectos: false,
+              tareas: false
+            }, ['slack'], false, {
+              setAgentToolGroups: jest.fn().mockResolvedValue(undefined),
+              saveAgentConnectors: saveAgentConnectors,
+              openConnectorAuthorizationWindows: jest.fn(function () {
+                return null;
+              }),
+              waitForConnectorAuthorization: jest.fn(),
+              connectorAuthErrorMessage: function connectorAuthErrorMessage() {
+                return 'connector error';
+              },
+              onConnectorAuthError: jest.fn(),
+              onConnectorSetupFailed: jest.fn(),
+              openAuthPopup: function openAuthPopup() {
+                return null;
+              },
+              closeAuthPopup: jest.fn()
+            }, function (key) {
+              return key;
+            });
+          case 1:
+            expect(saveAgentConnectors).not.toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    })));
+    it('does not report incomplete auth when authorization succeeds', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+      var onConnectorAuthError;
+      return _regeneratorRuntime.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            onConnectorAuthError = jest.fn();
+            _context3.next = 1;
+            return executeCreateAgentSideEffects({
+              id: '9'
+            }, {
+              clientes: true,
+              proyectos: false,
+              tareas: false
+            }, ['slack'], true, {
+              setAgentToolGroups: jest.fn().mockResolvedValue(undefined),
+              saveAgentConnectors: jest.fn().mockResolvedValue({
+                requires_auth: [{
+                  slug: 'slack'
+                }],
+                auth_errors: []
+              }),
+              openConnectorAuthorizationWindows: jest.fn(function () {
+                return null;
+              }),
+              waitForConnectorAuthorization: jest.fn().mockResolvedValue({
+                authorized: ['slack']
+              }),
+              connectorAuthErrorMessage: function connectorAuthErrorMessage() {
+                return 'connector error';
+              },
+              onConnectorAuthError: onConnectorAuthError,
+              onConnectorSetupFailed: jest.fn(),
+              openAuthPopup: function openAuthPopup() {
+                return null;
+              },
+              closeAuthPopup: jest.fn()
+            }, function (key) {
+              return key;
+            });
+          case 1:
+            expect(onConnectorAuthError).not.toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    })));
+    it('closes popup and reports connector setup failure', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+      var onConnectorSetupFailed, closeAuthPopup, popup;
+      return _regeneratorRuntime.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            onConnectorSetupFailed = jest.fn();
+            closeAuthPopup = jest.fn();
+            popup = {
+              closed: false
+            };
+            _context4.next = 1;
+            return executeCreateAgentSideEffects({
+              id: '9'
+            }, {
+              clientes: false,
+              proyectos: false,
+              tareas: false
+            }, ['slack'], true, {
+              setAgentToolGroups: jest.fn().mockRejectedValue(new Error('tool groups')),
+              saveAgentConnectors: jest.fn().mockRejectedValue(new Error('connectors')),
+              openConnectorAuthorizationWindows: jest.fn(function () {
+                return null;
+              }),
+              waitForConnectorAuthorization: jest.fn(),
+              connectorAuthErrorMessage: function connectorAuthErrorMessage() {
+                return 'connector error';
+              },
+              onConnectorAuthError: jest.fn(),
+              onConnectorSetupFailed: onConnectorSetupFailed,
+              openAuthPopup: function openAuthPopup() {
+                return popup;
+              },
+              closeAuthPopup: closeAuthPopup
+            }, function (key) {
+              return key;
+            });
+          case 1:
+            expect(onConnectorSetupFailed).toHaveBeenCalled();
+            expect(closeAuthPopup).toHaveBeenCalledWith(popup);
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    })));
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["buildCreateAgentSuccessPayload","parsedValuesByReq","resolveConnectorAuthErrorText","resolveConnectorAuthIncompleteMessage","resolveCreateAgentCorAccess","resolveCreateAgentSelectedConnectors","resolveCreateAgentSideEffectFlags","shouldCloseConnectorAuthPopup","shouldOpenConnectorAuthPopup","executeCreateAgentSideEffects","shouldRunCreateAgentSideEffects","describe","it","expect","name","userPrompt","aiModel","provider","model_name","toEqual","emoji","introduction","input_placeholder","user_prompt","undefined","clientes","proyectos","tareas","selectedConnectors","toBe","slug","message","error","toBeNull","id","toMatchObject","connectors","any","Array","closed","toolGroupsPayload","_asyncToGenerator","_regeneratorRuntime","mark","_callee","onConnectorAuthError","onConnectorSetupFailed","setAgentToolGroups","saveAgentConnectors","waitForConnectorAuthorization","closeAuthPopup","wrap","_context","prev","next","jest","fn","mockResolvedValue","requires_auth","auth_errors","authorized","openConnectorAuthorizationWindows","connectorAuthErrorMessage","openAuthPopup","key","toHaveBeenCalledWith","toHaveBeenCalled","not","stop","_callee2","_context2","_callee3","_context3","_callee4","popup","_context4","mockRejectedValue","Error"],"sources":["../../../src/hooks/useAgentModel/useCreateAgent.helpers.spec.ts"],"sourcesContent":["import {\n  buildCreateAgentSuccessPayload,\n  parsedValuesByReq,\n  resolveConnectorAuthErrorText,\n  resolveConnectorAuthIncompleteMessage,\n  resolveCreateAgentCorAccess,\n  resolveCreateAgentSelectedConnectors,\n  resolveCreateAgentSideEffectFlags,\n  shouldCloseConnectorAuthPopup,\n  shouldOpenConnectorAuthPopup,\n  executeCreateAgentSideEffects,\n  shouldRunCreateAgentSideEffects,\n} from './useCreateAgent.helpers'\n\ndescribe('useCreateAgent.helpers', () => {\n  describe('parsedValuesByReq', () => {\n    it('fills defaults for optional general fields', () => {\n      expect(\n        parsedValuesByReq({\n          name: 'Bot',\n          userPrompt: 'Help',\n          aiModel: { provider: 'openai', model_name: 'gpt-4' },\n        })\n      ).toEqual({\n        name: 'Bot',\n        emoji: '✨',\n        introduction: '',\n        input_placeholder: '',\n        user_prompt: 'Help',\n        provider: 'openai',\n        model_name: 'gpt-4',\n      })\n    })\n  })\n\n  describe('connector side effects', () => {\n    it('resolves cor access and selected connectors based on feature flag', () => {\n      expect(resolveCreateAgentCorAccess(undefined)).toEqual({\n        clientes: true,\n        proyectos: true,\n        tareas: true,\n      })\n      expect(resolveCreateAgentSelectedConnectors(false, { selectedConnectors: ['slack'] })).toEqual([])\n      expect(resolveCreateAgentSelectedConnectors(true, { selectedConnectors: ['slack'] })).toEqual(['slack'])\n      expect(shouldOpenConnectorAuthPopup(true, ['slack'])).toBe(true)\n      expect(shouldOpenConnectorAuthPopup(true, [])).toBe(false)\n    })\n\n    it('formats connector auth errors and incomplete auth messages', () => {\n      expect(\n        resolveConnectorAuthErrorText(\n          [{ slug: 'netsuite' }, { slug: 'other', message: 'fail' }],\n          'Setup netsuite',\n          error => error.message || 'generic'\n        )\n      ).toBe('Setup netsuite fail')\n\n      expect(resolveConnectorAuthIncompleteMessage(['slack'], undefined, 'timeout msg')).toBeNull()\n      expect(resolveConnectorAuthIncompleteMessage([], 'timeout', 'timeout msg')).toBe('timeout msg')\n      expect(resolveConnectorAuthIncompleteMessage([], 'custom', 'timeout msg')).toBe('custom')\n    })\n\n    it('builds success payload and popup guards', () => {\n      expect(buildCreateAgentSuccessPayload({ id: '1' }, { clientes: true }, ['slack'])).toMatchObject({\n        id: '1',\n        connectors: expect.any(Array),\n      })\n      expect(shouldCloseConnectorAuthPopup({ closed: false } as Window)).toBe(true)\n      expect(shouldCloseConnectorAuthPopup(null)).toBe(false)\n      expect(resolveCreateAgentSideEffectFlags().toolGroupsPayload({ clientes: true })).toEqual(['clientes'])\n    })\n\n    it('runs side effects for connectors, auth errors and incomplete auth', async () => {\n      const onConnectorAuthError = jest.fn()\n      const onConnectorSetupFailed = jest.fn()\n      const setAgentToolGroups = jest.fn().mockResolvedValue(undefined)\n      const saveAgentConnectors = jest.fn().mockResolvedValue({\n        requires_auth: [{ slug: 'slack' }],\n        auth_errors: [{ slug: 'netsuite' }],\n      })\n      const waitForConnectorAuthorization = jest.fn().mockResolvedValue({ authorized: [], error: 'timeout' })\n      const closeAuthPopup = jest.fn()\n\n      await executeCreateAgentSideEffects(\n        { id: '9' },\n        { clientes: true, proyectos: false, tareas: false },\n        ['slack'],\n        true,\n        {\n          setAgentToolGroups,\n          saveAgentConnectors,\n          openConnectorAuthorizationWindows: jest.fn(() => null),\n          waitForConnectorAuthorization,\n          connectorAuthErrorMessage: () => 'connector error',\n          onConnectorAuthError,\n          onConnectorSetupFailed,\n          openAuthPopup: () => ({ closed: false }) as Window,\n          closeAuthPopup,\n        },\n        key => key\n      )\n\n      expect(setAgentToolGroups).toHaveBeenCalledWith('9', ['clientes'])\n      expect(onConnectorAuthError).toHaveBeenCalled()\n      expect(onConnectorSetupFailed).not.toHaveBeenCalled()\n      expect(shouldRunCreateAgentSideEffects({ id: '1' })).toBe(true)\n      expect(shouldRunCreateAgentSideEffects({})).toBe(false)\n    })\n\n    it('skips connector side effects when external connectors are disabled', async () => {\n      const saveAgentConnectors = jest.fn()\n\n      await executeCreateAgentSideEffects(\n        { id: '9' },\n        { clientes: true, proyectos: false, tareas: false },\n        ['slack'],\n        false,\n        {\n          setAgentToolGroups: jest.fn().mockResolvedValue(undefined),\n          saveAgentConnectors,\n          openConnectorAuthorizationWindows: jest.fn(() => null),\n          waitForConnectorAuthorization: jest.fn(),\n          connectorAuthErrorMessage: () => 'connector error',\n          onConnectorAuthError: jest.fn(),\n          onConnectorSetupFailed: jest.fn(),\n          openAuthPopup: () => null,\n          closeAuthPopup: jest.fn(),\n        },\n        key => key\n      )\n\n      expect(saveAgentConnectors).not.toHaveBeenCalled()\n    })\n\n    it('does not report incomplete auth when authorization succeeds', async () => {\n      const onConnectorAuthError = jest.fn()\n\n      await executeCreateAgentSideEffects(\n        { id: '9' },\n        { clientes: true, proyectos: false, tareas: false },\n        ['slack'],\n        true,\n        {\n          setAgentToolGroups: jest.fn().mockResolvedValue(undefined),\n          saveAgentConnectors: jest.fn().mockResolvedValue({\n            requires_auth: [{ slug: 'slack' }],\n            auth_errors: [],\n          }),\n          openConnectorAuthorizationWindows: jest.fn(() => null),\n          waitForConnectorAuthorization: jest.fn().mockResolvedValue({ authorized: ['slack'] }),\n          connectorAuthErrorMessage: () => 'connector error',\n          onConnectorAuthError,\n          onConnectorSetupFailed: jest.fn(),\n          openAuthPopup: () => null,\n          closeAuthPopup: jest.fn(),\n        },\n        key => key\n      )\n\n      expect(onConnectorAuthError).not.toHaveBeenCalled()\n    })\n\n    it('closes popup and reports connector setup failure', async () => {\n      const onConnectorSetupFailed = jest.fn()\n      const closeAuthPopup = jest.fn()\n      const popup = { closed: false } as Window\n\n      await executeCreateAgentSideEffects(\n        { id: '9' },\n        { clientes: false, proyectos: false, tareas: false },\n        ['slack'],\n        true,\n        {\n          setAgentToolGroups: jest.fn().mockRejectedValue(new Error('tool groups')),\n          saveAgentConnectors: jest.fn().mockRejectedValue(new Error('connectors')),\n          openConnectorAuthorizationWindows: jest.fn(() => null),\n          waitForConnectorAuthorization: jest.fn(),\n          connectorAuthErrorMessage: () => 'connector error',\n          onConnectorAuthError: jest.fn(),\n          onConnectorSetupFailed,\n          openAuthPopup: () => popup,\n          closeAuthPopup,\n        },\n        key => key\n      )\n\n      expect(onConnectorSetupFailed).toHaveBeenCalled()\n      expect(closeAuthPopup).toHaveBeenCalledWith(popup)\n    })\n  })\n})\n"],"mappings":"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","ignoreList":[]}