@projectcor/maia-components 2.44.4 → 2.44.5-0

package/lib/hooks/useKnowledge/deleteKnowledge.spec.js

@@ -0,0 +1,122 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook } from '@testing-library/react';
+import { deleteKnowledge } from '../../services/maia/Knowledge';
+import { useDeleteKnowledge } from './deleteKnowledge';
+jest.mock('../../services/maia/Knowledge', function () {
+  return {
+    deleteKnowledge: jest.fn()
+  };
+});
+var handleSnackbarError = jest.fn();
+jest.mock('../useSnackBarManager/useSnackBarManager', function () {
+  return {
+    useSnackBarManager: function useSnackBarManager() {
+      return {
+        handleSnackbarError: handleSnackbarError
+      };
+    }
+  };
+});
+var deleteKnowledgeMock = deleteKnowledge;
+describe('useDeleteKnowledge', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    deleteKnowledgeMock.mockResolvedValue(true);
+  });
+  it('deletes knowledge and marks success', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _renderHook, result;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _renderHook = renderHook(function () {
+            return useDeleteKnowledge();
+          }), result = _renderHook.result;
+          _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.handleDeleteKnowledge(['kb-1', 'kb-2'], 'agent-1');
+                case 1:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+        case 1:
+          expect(deleteKnowledgeMock).toHaveBeenCalledWith(['kb-1', 'kb-2'], 'agent-1');
+          expect(result.current.success).toBe(true);
+          expect(result.current.error).toBeNull();
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('sets error and rethrows when delete fails', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _renderHook2, result;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          deleteKnowledgeMock.mockRejectedValue(new Error('Delete failed'));
+          _renderHook2 = renderHook(function () {
+            return useDeleteKnowledge();
+          }), result = _renderHook2.result;
+          _context4.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+            return _regeneratorRuntime.wrap(function (_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 1;
+                  return expect(result.current.handleDeleteKnowledge(['kb-1'], 'agent-1')).rejects.toThrow('Delete failed');
+                case 1:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+        case 1:
+          expect(result.current.error).toBe('Delete failed');
+          expect(handleSnackbarError).toHaveBeenCalledWith('deleteKnowledge');
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('resetSuccess clears the success flag', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+    var _renderHook3, result;
+    return _regeneratorRuntime.wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          _renderHook3 = renderHook(function () {
+            return useDeleteKnowledge();
+          }), result = _renderHook3.result;
+          _context6.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+            return _regeneratorRuntime.wrap(function (_context5) {
+              while (1) switch (_context5.prev = _context5.next) {
+                case 0:
+                  _context5.next = 1;
+                  return result.current.handleDeleteKnowledge(['kb-1'], 'agent-1');
+                case 1:
+                case "end":
+                  return _context5.stop();
+              }
+            }, _callee5);
+          })));
+        case 1:
+          act(function () {
+            result.current.handleResetSuccess();
+          });
+          expect(result.current.success).toBe(false);
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","deleteKnowledge","useDeleteKnowledge","jest","mock","fn","handleSnackbarError","useSnackBarManager","deleteKnowledgeMock","describe","beforeEach","clearAllMocks","mockResolvedValue","it","_asyncToGenerator","_regeneratorRuntime","mark","_callee2","_renderHook","result","wrap","_context2","prev","next","_callee","_context","current","handleDeleteKnowledge","stop","expect","toHaveBeenCalledWith","success","toBe","error","toBeNull","_callee4","_renderHook2","_context4","mockRejectedValue","Error","_callee3","_context3","rejects","toThrow","_callee6","_renderHook3","_context6","_callee5","_context5","handleResetSuccess"],"sources":["../../../src/hooks/useKnowledge/deleteKnowledge.spec.ts"],"sourcesContent":["import { act, renderHook } from '@testing-library/react'\nimport { deleteKnowledge } from '../../services/maia/Knowledge'\nimport { useDeleteKnowledge } from './deleteKnowledge'\n\njest.mock('../../services/maia/Knowledge', () => ({\n  deleteKnowledge: jest.fn(),\n}))\n\nconst handleSnackbarError = jest.fn()\n\njest.mock('../useSnackBarManager/useSnackBarManager', () => ({\n  useSnackBarManager: () => ({ handleSnackbarError }),\n}))\n\nconst deleteKnowledgeMock = deleteKnowledge as jest.MockedFunction<typeof deleteKnowledge>\n\ndescribe('useDeleteKnowledge', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n    deleteKnowledgeMock.mockResolvedValue(true)\n  })\n\n  it('deletes knowledge and marks success', async () => {\n    const { result } = renderHook(() => useDeleteKnowledge())\n\n    await act(async () => {\n      await result.current.handleDeleteKnowledge(['kb-1', 'kb-2'], 'agent-1')\n    })\n\n    expect(deleteKnowledgeMock).toHaveBeenCalledWith(['kb-1', 'kb-2'], 'agent-1')\n    expect(result.current.success).toBe(true)\n    expect(result.current.error).toBeNull()\n  })\n\n  it('sets error and rethrows when delete fails', async () => {\n    deleteKnowledgeMock.mockRejectedValue(new Error('Delete failed'))\n    const { result } = renderHook(() => useDeleteKnowledge())\n\n    await act(async () => {\n      await expect(result.current.handleDeleteKnowledge(['kb-1'], 'agent-1')).rejects.toThrow('Delete failed')\n    })\n\n    expect(result.current.error).toBe('Delete failed')\n    expect(handleSnackbarError).toHaveBeenCalledWith('deleteKnowledge')\n  })\n\n  it('resetSuccess clears the success flag', async () => {\n    const { result } = renderHook(() => useDeleteKnowledge())\n\n    await act(async () => {\n      await result.current.handleDeleteKnowledge(['kb-1'], 'agent-1')\n    })\n\n    act(() => {\n      result.current.handleResetSuccess()\n    })\n\n    expect(result.current.success).toBe(false)\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/hooks/useKnowledge/downloadKnowledge.spec.js

@@ -0,0 +1,148 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook } from '@testing-library/react';
+import { downloadKnowledge } from '../../services/maia/Knowledge/download';
+import { useDownloadKnowledge } from './downloadKnowledge';
+jest.mock('../../services/maia/Knowledge/download', function () {
+  return {
+    downloadKnowledge: jest.fn()
+  };
+});
+var handleSnackbarError = jest.fn();
+jest.mock('../useSnackBarManager/useSnackBarManager', function () {
+  return {
+    useSnackBarManager: function useSnackBarManager() {
+      return {
+        handleSnackbarError: handleSnackbarError
+      };
+    }
+  };
+});
+var downloadKnowledgeMock = downloadKnowledge;
+var downloadPayload = {
+  blob: new Blob(['pdf']),
+  filename: 'doc.pdf',
+  contentType: 'application/pdf',
+  size: 3
+};
+describe('useDownloadKnowledge', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    downloadKnowledgeMock.mockResolvedValue(downloadPayload);
+  });
+  it('stores the download payload on success', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _renderHook, result, response;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _renderHook = renderHook(function () {
+            return useDownloadKnowledge();
+          }), result = _renderHook.result;
+          _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.handleDownloadKnowledge({
+                    agentId: 'agent-1',
+                    knowledgeId: 'kb-1'
+                  });
+                case 1:
+                  response = _context.sent;
+                case 2:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+        case 1:
+          expect(downloadKnowledgeMock).toHaveBeenCalledWith({
+            agentId: 'agent-1',
+            knowledgeId: 'kb-1'
+          });
+          expect(response).toEqual(downloadPayload);
+          expect(result.current.success).toEqual(downloadPayload);
+          expect(result.current.error).toBeNull();
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('returns null and shows snackbar on failure', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _renderHook2, result, response;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          downloadKnowledgeMock.mockRejectedValue(new Error('Not found'));
+          _renderHook2 = renderHook(function () {
+            return useDownloadKnowledge();
+          }), result = _renderHook2.result;
+          _context4.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+            return _regeneratorRuntime.wrap(function (_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 1;
+                  return result.current.handleDownloadKnowledge({
+                    agentId: 'agent-1',
+                    knowledgeId: 'kb-9'
+                  });
+                case 1:
+                  response = _context3.sent;
+                case 2:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+        case 1:
+          expect(response).toBeNull();
+          expect(result.current.error).toBe('Not found');
+          expect(handleSnackbarError).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('resetStates clears loading, error and success', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+    var _renderHook3, result;
+    return _regeneratorRuntime.wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          _renderHook3 = renderHook(function () {
+            return useDownloadKnowledge();
+          }), result = _renderHook3.result;
+          _context6.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+            return _regeneratorRuntime.wrap(function (_context5) {
+              while (1) switch (_context5.prev = _context5.next) {
+                case 0:
+                  _context5.next = 1;
+                  return result.current.handleDownloadKnowledge({
+                    agentId: 'agent-1',
+                    knowledgeId: 'kb-1'
+                  });
+                case 1:
+                case "end":
+                  return _context5.stop();
+              }
+            }, _callee5);
+          })));
+        case 1:
+          act(function () {
+            result.current.handleResetStates();
+          });
+          expect(result.current.success).toBeNull();
+          expect(result.current.error).toBeNull();
+          expect(result.current.isLoading).toBe(false);
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","downloadKnowledge","useDownloadKnowledge","jest","mock","fn","handleSnackbarError","useSnackBarManager","downloadKnowledgeMock","downloadPayload","blob","Blob","filename","contentType","size","describe","beforeEach","clearAllMocks","mockResolvedValue","it","_asyncToGenerator","_regeneratorRuntime","mark","_callee2","_renderHook","result","response","wrap","_context2","prev","next","_callee","_context","current","handleDownloadKnowledge","agentId","knowledgeId","sent","stop","expect","toHaveBeenCalledWith","toEqual","success","error","toBeNull","_callee4","_renderHook2","_context4","mockRejectedValue","Error","_callee3","_context3","toBe","toHaveBeenCalled","_callee6","_renderHook3","_context6","_callee5","_context5","handleResetStates","isLoading"],"sources":["../../../src/hooks/useKnowledge/downloadKnowledge.spec.ts"],"sourcesContent":["import { act, renderHook } from '@testing-library/react'\nimport { downloadKnowledge } from '../../services/maia/Knowledge/download'\nimport { useDownloadKnowledge } from './downloadKnowledge'\n\njest.mock('../../services/maia/Knowledge/download', () => ({\n  downloadKnowledge: jest.fn(),\n}))\n\nconst handleSnackbarError = jest.fn()\n\njest.mock('../useSnackBarManager/useSnackBarManager', () => ({\n  useSnackBarManager: () => ({ handleSnackbarError }),\n}))\n\nconst downloadKnowledgeMock = downloadKnowledge as jest.MockedFunction<typeof downloadKnowledge>\n\nconst downloadPayload = {\n  blob: new Blob(['pdf']),\n  filename: 'doc.pdf',\n  contentType: 'application/pdf',\n  size: 3,\n}\n\ndescribe('useDownloadKnowledge', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n    downloadKnowledgeMock.mockResolvedValue(downloadPayload)\n  })\n\n  it('stores the download payload on success', async () => {\n    const { result } = renderHook(() => useDownloadKnowledge())\n\n    let response: unknown\n    await act(async () => {\n      response = await result.current.handleDownloadKnowledge({ agentId: 'agent-1', knowledgeId: 'kb-1' })\n    })\n\n    expect(downloadKnowledgeMock).toHaveBeenCalledWith({ agentId: 'agent-1', knowledgeId: 'kb-1' })\n    expect(response).toEqual(downloadPayload)\n    expect(result.current.success).toEqual(downloadPayload)\n    expect(result.current.error).toBeNull()\n  })\n\n  it('returns null and shows snackbar on failure', async () => {\n    downloadKnowledgeMock.mockRejectedValue(new Error('Not found'))\n    const { result } = renderHook(() => useDownloadKnowledge())\n\n    let response: unknown\n    await act(async () => {\n      response = await result.current.handleDownloadKnowledge({ agentId: 'agent-1', knowledgeId: 'kb-9' })\n    })\n\n    expect(response).toBeNull()\n    expect(result.current.error).toBe('Not found')\n    expect(handleSnackbarError).toHaveBeenCalled()\n  })\n\n  it('resetStates clears loading, error and success', async () => {\n    const { result } = renderHook(() => useDownloadKnowledge())\n\n    await act(async () => {\n      await result.current.handleDownloadKnowledge({ agentId: 'agent-1', knowledgeId: 'kb-1' })\n    })\n\n    act(() => {\n      result.current.handleResetStates()\n    })\n\n    expect(result.current.success).toBeNull()\n    expect(result.current.error).toBeNull()\n    expect(result.current.isLoading).toBe(false)\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/hooks/useKnowledge/saveKnowledge.spec.js

@@ -0,0 +1,104 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook } from '@testing-library/react';
+import { saveKnowledge } from '../../services/maia/Knowledge';
+import { useSaveKnowledge } from './saveKnowledge';
+jest.mock('../../services/maia/Knowledge', function () {
+  return {
+    saveKnowledge: jest.fn()
+  };
+});
+var handleSnackbarError = jest.fn();
+jest.mock('../useSnackBarManager/useSnackBarManager', function () {
+  return {
+    useSnackBarManager: function useSnackBarManager() {
+      return {
+        handleSnackbarError: handleSnackbarError
+      };
+    }
+  };
+});
+var saveKnowledgeMock = saveKnowledge;
+describe('useSaveKnowledge', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    saveKnowledgeMock.mockResolvedValue({
+      ok: true
+    });
+  });
+  it('saves knowledge and stores the success payload', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var knowledge, _renderHook, result, response;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          knowledge = [{
+            filename: 'doc.pdf'
+          }];
+          _renderHook = renderHook(function () {
+            return useSaveKnowledge();
+          }), result = _renderHook.result;
+          _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.handleSaveKnowledge(knowledge, 'agent-1');
+                case 1:
+                  response = _context.sent;
+                case 2:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+        case 1:
+          expect(saveKnowledgeMock).toHaveBeenCalledWith(knowledge, 'agent-1');
+          expect(response).toEqual({
+            ok: true
+          });
+          expect(result.current.success).toEqual({
+            ok: true
+          });
+          expect(result.current.error).toBeNull();
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('handles errors from handleSaveMultipleKnowledge', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _renderHook2, result;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          saveKnowledgeMock.mockRejectedValue(new Error('Upload failed'));
+          _renderHook2 = renderHook(function () {
+            return useSaveKnowledge();
+          }), result = _renderHook2.result;
+          _context4.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+            return _regeneratorRuntime.wrap(function (_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 1;
+                  return expect(result.current.handleSaveMultipleKnowledge([{
+                    filename: 'a.pdf'
+                  }], 'agent-2')).rejects.toThrow('Upload failed');
+                case 1:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+        case 1:
+          expect(result.current.error).toBe('Upload failed');
+          expect(handleSnackbarError).toHaveBeenCalledWith('saveKnowledge');
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/hooks/useKnowledge/useKnowledgeOperations.spec.js

@@ -0,0 +1,178 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { act, renderHook } from '@testing-library/react';
+import { useKnowledgeOperations } from './useKnowledgeOperations';
+var handleSaveMultipleKnowledge = jest.fn();
+var handleDeleteKnowledge = jest.fn();
+jest.mock('./saveKnowledge', function () {
+  return {
+    useSaveKnowledge: function useSaveKnowledge() {
+      return {
+        handleSaveMultipleKnowledge: handleSaveMultipleKnowledge,
+        isLoading: false,
+        success: false,
+        error: null,
+        handleResetSuccess: jest.fn()
+      };
+    }
+  };
+});
+jest.mock('./deleteKnowledge', function () {
+  return {
+    useDeleteKnowledge: function useDeleteKnowledge() {
+      return {
+        handleDeleteKnowledge: handleDeleteKnowledge,
+        isLoading: false,
+        success: false,
+        error: null,
+        handleResetSuccess: jest.fn()
+      };
+    }
+  };
+});
+describe('useKnowledgeOperations', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    handleSaveMultipleKnowledge.mockResolvedValue({
+      ok: true
+    });
+    handleDeleteKnowledge.mockResolvedValue(true);
+  });
+  it('maps attachment files to knowledge payloads', function () {
+    var _renderHook = renderHook(function () {
+        return useKnowledgeOperations();
+      }),
+      result = _renderHook.result;
+    var file = new File(['x'], 'notes.pdf', {
+      type: 'application/pdf'
+    });
+    expect(result.current.convertAttachmentToKnowledge([{
+      id: '1',
+      name: 'notes.pdf',
+      size: 120,
+      type: 'application/pdf',
+      file: file
+    }])).toEqual([{
+      filename: 'notes.pdf',
+      original_file_type: 'application/pdf',
+      file_size_bytes: 120,
+      file: file
+    }]);
+  });
+  it('creates knowledge through the save hook', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _renderHook2, result, files;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _renderHook2 = renderHook(function () {
+            return useKnowledgeOperations();
+          }), result = _renderHook2.result;
+          files = [{
+            id: '1',
+            name: 'a.pdf'
+          }];
+          _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.handleCreateKnowledges({
+                    agentId: 'agent-1',
+                    files: files
+                  });
+                case 1:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+        case 1:
+          expect(handleSaveMultipleKnowledge).toHaveBeenCalledWith(files, 'agent-1');
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('deletes knowledge ids from attachment refs', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _renderHook3, result, files;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _renderHook3 = renderHook(function () {
+            return useKnowledgeOperations();
+          }), result = _renderHook3.result;
+          files = [{
+            id: 'kb-1'
+          }, {
+            id: 'kb-2'
+          }];
+          _context4.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+            return _regeneratorRuntime.wrap(function (_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 1;
+                  return result.current.handleDeleteKnowledges({
+                    agentId: 'agent-2',
+                    files: files
+                  });
+                case 1:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })));
+        case 1:
+          expect(handleDeleteKnowledge).toHaveBeenCalledWith(['kb-1', 'kb-2'], 'agent-2');
+        case 2:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('runs delete then create when both operations are requested', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+    var _renderHook4, result;
+    return _regeneratorRuntime.wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          _renderHook4 = renderHook(function () {
+            return useKnowledgeOperations();
+          }), result = _renderHook4.result;
+          _context6.next = 1;
+          return act(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+            return _regeneratorRuntime.wrap(function (_context5) {
+              while (1) switch (_context5.prev = _context5.next) {
+                case 0:
+                  _context5.next = 1;
+                  return result.current.handleDeleteAndCreateKnowledges({
+                    agentId: 'agent-3',
+                    filesToDelete: [{
+                      id: 'old-1'
+                    }],
+                    filesToCreate: [{
+                      id: 'new-1',
+                      name: 'new.pdf'
+                    }]
+                  });
+                case 1:
+                case "end":
+                  return _context5.stop();
+              }
+            }, _callee5);
+          })));
+        case 1:
+          expect(handleDeleteKnowledge).toHaveBeenCalledWith(['old-1'], 'agent-3');
+          expect(handleSaveMultipleKnowledge).toHaveBeenCalledWith([{
+            id: 'new-1',
+            name: 'new.pdf'
+          }], 'agent-3');
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["act","renderHook","useKnowledgeOperations","handleSaveMultipleKnowledge","jest","fn","handleDeleteKnowledge","mock","useSaveKnowledge","isLoading","success","error","handleResetSuccess","useDeleteKnowledge","describe","beforeEach","clearAllMocks","mockResolvedValue","ok","it","_renderHook","result","file","File","type","expect","current","convertAttachmentToKnowledge","id","name","size","toEqual","filename","original_file_type","file_size_bytes","_asyncToGenerator","_regeneratorRuntime","mark","_callee2","_renderHook2","files","wrap","_context2","prev","next","_callee","_context","handleCreateKnowledges","agentId","stop","toHaveBeenCalledWith","_callee4","_renderHook3","_context4","_callee3","_context3","handleDeleteKnowledges","_callee6","_renderHook4","_context6","_callee5","_context5","handleDeleteAndCreateKnowledges","filesToDelete","filesToCreate"],"sources":["../../../src/hooks/useKnowledge/useKnowledgeOperations.spec.ts"],"sourcesContent":["import { act, renderHook } from '@testing-library/react'\nimport { useKnowledgeOperations } from './useKnowledgeOperations'\n\nconst handleSaveMultipleKnowledge = jest.fn()\nconst handleDeleteKnowledge = jest.fn()\n\njest.mock('./saveKnowledge', () => ({\n  useSaveKnowledge: () => ({\n    handleSaveMultipleKnowledge,\n    isLoading: false,\n    success: false,\n    error: null,\n    handleResetSuccess: jest.fn(),\n  }),\n}))\n\njest.mock('./deleteKnowledge', () => ({\n  useDeleteKnowledge: () => ({\n    handleDeleteKnowledge,\n    isLoading: false,\n    success: false,\n    error: null,\n    handleResetSuccess: jest.fn(),\n  }),\n}))\n\ndescribe('useKnowledgeOperations', () => {\n  beforeEach(() => {\n    jest.clearAllMocks()\n    handleSaveMultipleKnowledge.mockResolvedValue({ ok: true })\n    handleDeleteKnowledge.mockResolvedValue(true)\n  })\n\n  it('maps attachment files to knowledge payloads', () => {\n    const { result } = renderHook(() => useKnowledgeOperations())\n    const file = new File(['x'], 'notes.pdf', { type: 'application/pdf' })\n\n    expect(\n      result.current.convertAttachmentToKnowledge([\n        { id: '1', name: 'notes.pdf', size: 120, type: 'application/pdf', file },\n      ])\n    ).toEqual([\n      {\n        filename: 'notes.pdf',\n        original_file_type: 'application/pdf',\n        file_size_bytes: 120,\n        file,\n      },\n    ])\n  })\n\n  it('creates knowledge through the save hook', async () => {\n    const { result } = renderHook(() => useKnowledgeOperations())\n    const files = [{ id: '1', name: 'a.pdf' }]\n\n    await act(async () => {\n      await result.current.handleCreateKnowledges({ agentId: 'agent-1', files })\n    })\n\n    expect(handleSaveMultipleKnowledge).toHaveBeenCalledWith(files, 'agent-1')\n  })\n\n  it('deletes knowledge ids from attachment refs', async () => {\n    const { result } = renderHook(() => useKnowledgeOperations())\n    const files = [{ id: 'kb-1' }, { id: 'kb-2' }]\n\n    await act(async () => {\n      await result.current.handleDeleteKnowledges({ agentId: 'agent-2', files })\n    })\n\n    expect(handleDeleteKnowledge).toHaveBeenCalledWith(['kb-1', 'kb-2'], 'agent-2')\n  })\n\n  it('runs delete then create when both operations are requested', async () => {\n    const { result } = renderHook(() => useKnowledgeOperations())\n\n    await act(async () => {\n      await result.current.handleDeleteAndCreateKnowledges({\n        agentId: 'agent-3',\n        filesToDelete: [{ id: 'old-1' }],\n        filesToCreate: [{ id: 'new-1', name: 'new.pdf' }],\n      })\n    })\n\n    expect(handleDeleteKnowledge).toHaveBeenCalledWith(['old-1'], 'agent-3')\n    expect(handleSaveMultipleKnowledge).toHaveBeenCalledWith([{ id: 'new-1', name: 'new.pdf' }], 'agent-3')\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/lib/hooks/useMaiaChatSessionMeta/index.js

@@ -0,0 +1,2 @@
+export { useMaiaChatSessionMeta } from './useMaiaChatSessionMeta';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ1c2VNYWlhQ2hhdFNlc3Npb25NZXRhIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2hvb2tzL3VzZU1haWFDaGF0U2Vzc2lvbk1ldGEvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgdXNlTWFpYUNoYXRTZXNzaW9uTWV0YSB9IGZyb20gJy4vdXNlTWFpYUNoYXRTZXNzaW9uTWV0YSdcbiJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0Esc0JBQXNCLFFBQVEsMEJBQTBCIiwiaWdub3JlTGlzdCI6W119

package/lib/hooks/useMaiaChatSessionMeta/useMaiaChatSessionMeta.js

@@ -0,0 +1,24 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useEffect, useState } from 'react';
+export function useMaiaChatSessionMeta(initialChatId) {
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    sessionMeta = _useState2[0],
+    setSessionMeta = _useState2[1];
+  useEffect(function () {
+    var onSessionMeta = function onSessionMeta(evt) {
+      var _ref = evt,
+        detail = _ref.detail;
+      if (detail) setSessionMeta(detail);
+    };
+    document.addEventListener('maia-chat-session-meta', onSessionMeta);
+    return function () {
+      document.removeEventListener('maia-chat-session-meta', onSessionMeta);
+    };
+  }, []);
+  useEffect(function () {
+    setSessionMeta(null);
+  }, [initialChatId]);
+  return sessionMeta;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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