@projectcor/maia-components 2.49.0 → 2.49.1-1

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":[]}

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

@@ -0,0 +1,314 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook } from '@testing-library/react';
+import { createAgent } from '../../services/maia/Agents/createAgent';
+import { setAgentToolGroups } from '../../services/maia/Agents/setAgentToolGroups';
+import { saveAgentConnectors } from '../../services/maia/Agents/connectors';
+import { parsedValuesByReq, useCreateAgent } from './useCreateAgent';
+jest.mock('../../services/maia/Agents/createAgent', function () {
+  return {
+    createAgent: jest.fn()
+  };
+});
+jest.mock('../../services/maia/Agents/setAgentToolGroups', function () {
+  return {
+    setAgentToolGroups: jest.fn()
+  };
+});
+var handleSnackbarError = jest.fn();
+jest.mock('../useSnackBarManager/useSnackBarManager', function () {
+  return {
+    useSnackBarManager: function useSnackBarManager() {
+      return {
+        handleSnackbarError: handleSnackbarError
+      };
+    }
+  };
+});
+jest.mock('../../services/maia/Agents/connectors', function () {
+  return {
+    saveAgentConnectors: jest.fn(),
+    openConnectorAuthorizationWindows: jest.fn(function () {
+      return null;
+    }),
+    waitForConnectorAuthorization: jest.fn(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", {
+              authorized: ['slack'],
+              error: undefined
+            });
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))),
+    connectorAuthErrorMessage: jest.fn(function () {
+      return 'connector error';
+    })
+  };
+});
+jest.mock('../../constants/maiaExternalConnectorsAccess', function () {
+  return {
+    hasMaiaExternalConnectorsAccess: jest.fn(function () {
+      return true;
+    })
+  };
+});
+var createAgentMock = createAgent;
+var setAgentToolGroupsMock = setAgentToolGroups;
+var saveAgentConnectorsMock = saveAgentConnectors;
+var values = {
+  general: {
+    name: 'Legal',
+    userPrompt: 'Sos legal',
+    aiModel: {
+      provider: 'openai',
+      model_name: 'gpt'
+    }
+  },
+  accessibility: {
+    corAccess: {
+      clientes: true,
+      proyectos: false,
+      tareas: true
+    }
+  }
+};
+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('useCreateAgent', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    createAgentMock.mockResolvedValue({
+      id: 'a1'
+    });
+    setAgentToolGroupsMock.mockResolvedValue({
+      ok: true
+    });
+    saveAgentConnectorsMock.mockResolvedValue({
+      requires_auth: [],
+      auth_errors: []
+    });
+  });
+  it('creates the agent and posts the selected COR slugs', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var _renderHook, result;
+    return _regeneratorRuntime.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _renderHook = renderHook(function () {
+            return useCreateAgent();
+          }), result = _renderHook.result;
+          _context3.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+            return _regeneratorRuntime.wrap(function (_context2) {
+              while (1) switch (_context2.prev = _context2.next) {
+                case 0:
+                  _context2.next = 1;
+                  return result.current.handleCreateAgent(values);
+                case 1:
+                case "end":
+                  return _context2.stop();
+              }
+            }, _callee2);
+          })));
+        case 1:
+          expect(setAgentToolGroupsMock).toHaveBeenCalledWith('a1', ['clientes', 'tareas']);
+          expect(result.current.success).toEqual({
+            id: 'a1',
+            connectors: [{
+              group: 'COR',
+              slugs: ['clientes', 'tareas']
+            }, {
+              group: 'MCP',
+              slugs: []
+            }]
+          });
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('ignores duplicate submissions while a create is in flight', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+    var resolveCreate, _renderHook2, result, firstCall, secondCall;
+    return _regeneratorRuntime.wrap(function (_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          resolveCreate = function resolveCreate() {
+            return undefined;
+          };
+          createAgentMock.mockImplementation(function () {
+            return new Promise(function (resolve) {
+              resolveCreate = resolve;
+            });
+          });
+          _renderHook2 = renderHook(function () {
+            return useCreateAgent();
+          }), result = _renderHook2.result;
+          act(function () {
+            firstCall = result.current.handleCreateAgent(values);
+            secondCall = result.current.handleCreateAgent(values);
+          });
+          expect(createAgentMock).toHaveBeenCalledTimes(1);
+          _context5.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+            return _regeneratorRuntime.wrap(function (_context4) {
+              while (1) switch (_context4.prev = _context4.next) {
+                case 0:
+                  resolveCreate({
+                    id: 'a1'
+                  });
+                  _context4.next = 1;
+                  return firstCall;
+                case 1:
+                  _context4.next = 2;
+                  return secondCall;
+                case 2:
+                case "end":
+                  return _context4.stop();
+              }
+            }, _callee4);
+          })));
+        case 1:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  })));
+  it('surfaces API errors through snackbar and error state', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+    var _renderHook3, result;
+    return _regeneratorRuntime.wrap(function (_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          createAgentMock.mockResolvedValue({
+            error: 'duplicate name'
+          });
+          _renderHook3 = renderHook(function () {
+            return useCreateAgent();
+          }), result = _renderHook3.result;
+          _context7.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+            return _regeneratorRuntime.wrap(function (_context6) {
+              while (1) switch (_context6.prev = _context6.next) {
+                case 0:
+                  _context6.next = 1;
+                  return result.current.handleCreateAgent(values);
+                case 1:
+                case "end":
+                  return _context6.stop();
+              }
+            }, _callee6);
+          })));
+        case 1:
+          expect(handleSnackbarError).toHaveBeenCalledWith('errorAgentCreated');
+          expect(result.current.error).toBe('duplicate name');
+          expect(result.current.success).toBe(false);
+        case 2:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  })));
+  it('saves external connectors when the feature is enabled', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+    var _renderHook4, result;
+    return _regeneratorRuntime.wrap(function (_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          saveAgentConnectorsMock.mockResolvedValue({
+            requires_auth: [{
+              slug: 'slack'
+            }],
+            auth_errors: [{
+              slug: 'netsuite'
+            }]
+          });
+          _renderHook4 = renderHook(function () {
+            return useCreateAgent();
+          }), result = _renderHook4.result;
+          _context9.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+            return _regeneratorRuntime.wrap(function (_context8) {
+              while (1) switch (_context8.prev = _context8.next) {
+                case 0:
+                  _context8.next = 1;
+                  return result.current.handleCreateAgent(_objectSpread(_objectSpread({}, values), {}, {
+                    accessibility: _objectSpread(_objectSpread({}, values.accessibility), {}, {
+                      selectedConnectors: ['slack']
+                    })
+                  }));
+                case 1:
+                case "end":
+                  return _context8.stop();
+              }
+            }, _callee8);
+          })));
+        case 1:
+          expect(saveAgentConnectorsMock).toHaveBeenCalledWith('a1', ['slack']);
+          expect(handleSnackbarError).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9);
+  })));
+  it('resets success state on demand', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee1() {
+    var _renderHook5, result;
+    return _regeneratorRuntime.wrap(function (_context1) {
+      while (1) switch (_context1.prev = _context1.next) {
+        case 0:
+          _renderHook5 = renderHook(function () {
+            return useCreateAgent();
+          }), result = _renderHook5.result;
+          _context1.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0() {
+            return _regeneratorRuntime.wrap(function (_context0) {
+              while (1) switch (_context0.prev = _context0.next) {
+                case 0:
+                  _context0.next = 1;
+                  return result.current.handleCreateAgent(values);
+                case 1:
+                case "end":
+                  return _context0.stop();
+              }
+            }, _callee0);
+          })));
+        case 1:
+          expect(result.current.success).toEqual(expect.objectContaining({
+            id: 'a1'
+          }));
+          act(function () {
+            result.current.resetSuccess();
+          });
+          expect(result.current.success).toBe(false);
+        case 2:
+        case "end":
+          return _context1.stop();
+      }
+    }, _callee1);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","createAgent","setAgentToolGroups","saveAgentConnectors","parsedValuesByReq","useCreateAgent","jest","mock","fn","handleSnackbarError","useSnackBarManager","openConnectorAuthorizationWindows","waitForConnectorAuthorization","_asyncToGenerator","_regeneratorRuntime","mark","_callee","wrap","_context","prev","next","abrupt","authorized","error","undefined","stop","connectorAuthErrorMessage","hasMaiaExternalConnectorsAccess","createAgentMock","setAgentToolGroupsMock","saveAgentConnectorsMock","values","general","name","userPrompt","aiModel","provider","model_name","accessibility","corAccess","clientes","proyectos","tareas","describe","it","expect","toEqual","emoji","introduction","input_placeholder","user_prompt","beforeEach","clearAllMocks","mockResolvedValue","id","ok","requires_auth","auth_errors","_callee3","_renderHook","result","_context3","_callee2","_context2","current","handleCreateAgent","toHaveBeenCalledWith","success","connectors","group","slugs","_callee5","resolveCreate","_renderHook2","firstCall","secondCall","_context5","mockImplementation","Promise","resolve","toHaveBeenCalledTimes","_callee4","_context4","_callee7","_renderHook3","_context7","_callee6","_context6","toBe","_callee9","_renderHook4","_context9","slug","_callee8","_context8","_objectSpread","selectedConnectors","toHaveBeenCalled","_callee1","_renderHook5","_context1","_callee0","_context0","objectContaining","resetSuccess"],"sources":["../../../src/hooks/useAgentModel/useCreateAgent.spec.ts"],"sourcesContent":["import { act, renderHook } from '@testing-library/react'\nimport { createAgent } from '../../services/maia/Agents/createAgent'\nimport { setAgentToolGroups } from '../../services/maia/Agents/setAgentToolGroups'\nimport { saveAgentConnectors } from '../../services/maia/Agents/connectors'\nimport { parsedValuesByReq, useCreateAgent } from './useCreateAgent'\n\njest.mock('../../services/maia/Agents/createAgent', () => ({\n  createAgent: jest.fn(),\n}))\n\njest.mock('../../services/maia/Agents/setAgentToolGroups', () => ({\n  setAgentToolGroups: jest.fn(),\n}))\n\nconst handleSnackbarError = jest.fn()\n\njest.mock('../useSnackBarManager/useSnackBarManager', () => ({\n  useSnackBarManager: () => ({ handleSnackbarError }),\n}))\n\njest.mock('../../services/maia/Agents/connectors', () => ({\n  saveAgentConnectors: jest.fn(),\n  openConnectorAuthorizationWindows: jest.fn(() => null),\n  waitForConnectorAuthorization: jest.fn(async () => ({ authorized: ['slack'], error: undefined })),\n  connectorAuthErrorMessage: jest.fn(() => 'connector error'),\n}))\n\njest.mock('../../constants/maiaExternalConnectorsAccess', () => ({\n  hasMaiaExternalConnectorsAccess: jest.fn(() => true),\n}))\n\nconst createAgentMock = createAgent as jest.MockedFunction<typeof createAgent>\nconst setAgentToolGroupsMock = setAgentToolGroups as jest.MockedFunction<typeof setAgentToolGroups>\nconst saveAgentConnectorsMock = saveAgentConnectors as jest.MockedFunction<typeof saveAgentConnectors>\n\nconst values = {\n  general: {\n    name: 'Legal',\n    userPrompt: 'Sos legal',\n    aiModel: { provider: 'openai', model_name: 'gpt' },\n  },\n  accessibility: {\n    corAccess: { clientes: true, proyectos: false, tareas: true },\n  },\n}\n\ndescribe('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\ndescribe('useCreateAgent', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n    createAgentMock.mockResolvedValue({ id: 'a1' } as never)\n    setAgentToolGroupsMock.mockResolvedValue({ ok: true } as never)\n    saveAgentConnectorsMock.mockResolvedValue({ requires_auth: [], auth_errors: [] } as never)\n  })\n\n  it('creates the agent and posts the selected COR slugs', async () => {\n    const { result } = renderHook(() => useCreateAgent())\n\n    await act(async () => {\n      await result.current.handleCreateAgent(values)\n    })\n\n    expect(setAgentToolGroupsMock).toHaveBeenCalledWith('a1', ['clientes', 'tareas'])\n    expect(result.current.success).toEqual({\n      id: 'a1',\n      connectors: [\n        { group: 'COR', slugs: ['clientes', 'tareas'] },\n        { group: 'MCP', slugs: [] },\n      ],\n    })\n  })\n\n  it('ignores duplicate submissions while a create is in flight', async () => {\n    let resolveCreate: (value: { id: string }) => void = () => undefined\n    createAgentMock.mockImplementation(\n      () =>\n        new Promise(resolve => {\n          resolveCreate = resolve\n        }) as never\n    )\n\n    const { result } = renderHook(() => useCreateAgent())\n\n    let firstCall: Promise<void>\n    let secondCall: Promise<void>\n    act(() => {\n      firstCall = result.current.handleCreateAgent(values)\n      secondCall = result.current.handleCreateAgent(values)\n    })\n\n    expect(createAgentMock).toHaveBeenCalledTimes(1)\n\n    await act(async () => {\n      resolveCreate({ id: 'a1' })\n      await firstCall\n      await secondCall\n    })\n  })\n\n  it('surfaces API errors through snackbar and error state', async () => {\n    createAgentMock.mockResolvedValue({ error: 'duplicate name' } as never)\n\n    const { result } = renderHook(() => useCreateAgent())\n\n    await act(async () => {\n      await result.current.handleCreateAgent(values)\n    })\n\n    expect(handleSnackbarError).toHaveBeenCalledWith('errorAgentCreated')\n    expect(result.current.error).toBe('duplicate name')\n    expect(result.current.success).toBe(false)\n  })\n\n  it('saves external connectors when the feature is enabled', async () => {\n    saveAgentConnectorsMock.mockResolvedValue({\n      requires_auth: [{ slug: 'slack' }],\n      auth_errors: [{ slug: 'netsuite' }],\n    } as never)\n\n    const { result } = renderHook(() => useCreateAgent())\n\n    await act(async () => {\n      await result.current.handleCreateAgent({\n        ...values,\n        accessibility: {\n          ...values.accessibility,\n          selectedConnectors: ['slack'],\n        },\n      })\n    })\n\n    expect(saveAgentConnectorsMock).toHaveBeenCalledWith('a1', ['slack'])\n    expect(handleSnackbarError).toHaveBeenCalled()\n  })\n\n  it('resets success state on demand', async () => {\n    const { result } = renderHook(() => useCreateAgent())\n\n    await act(async () => {\n      await result.current.handleCreateAgent(values)\n    })\n\n    expect(result.current.success).toEqual(expect.objectContaining({ id: 'a1' }))\n\n    act(() => {\n      result.current.resetSuccess()\n    })\n\n    expect(result.current.success).toBe(false)\n  })\n})\n"],"mappings":"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","ignoreList":[]}