cozy-search 2.2.29 → 2.3.0

package/dist/components/KnowledgeBase/ragIndexing.js

@@ -0,0 +1,415 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setupRagIndexing = exports.migrateAssistantsWithoutFolder = exports.makeRagIndexTriggerAttributes = exports.findRagIndexTriggers = exports.RAG_INDEX_WORKER = exports.RAG_INDEX_FILES_DEBOUNCE = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _knowledgeBase = require("./knowledgeBase");
+
+var _queries = require("../queries");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var RAG_INDEX_WORKER = 'rag-index';
+exports.RAG_INDEX_WORKER = RAG_INDEX_WORKER;
+var RAG_INDEX_FILES_DEBOUNCE = '30s';
+exports.RAG_INDEX_FILES_DEBOUNCE = RAG_INDEX_FILES_DEBOUNCE;
+var TRIGGERS_DOCTYPE = 'io.cozy.triggers';
+
+var warn = function warn() {
+  var _console;
+
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  // eslint-disable-next-line no-console
+  (_console = console).warn.apply(_console, ['cozy-search rag indexing:'].concat(args));
+};
+/**
+ * The two rag-index triggers of an instance: one on the files (debounced,
+ * they change often), one on the assistants (a knowledge base change must
+ * be seen at once). Both carry the same message.
+ */
+
+
+var makeRagIndexTriggerAttributes = function makeRagIndexTriggerAttributes(doctype) {
+  return _objectSpread(_objectSpread({
+    type: '@event',
+    arguments: doctype
+  }, doctype === _queries.FILES_DOCTYPE ? {
+    debounce: RAG_INDEX_FILES_DEBOUNCE
+  } : {}), {}, {
+    worker: RAG_INDEX_WORKER,
+    message: {
+      doctype: _queries.FILES_DOCTYPE
+    }
+  });
+};
+/**
+ * Lists the rag-index triggers of the instance by kind.
+ * @returns {Promise<{ files: object|null, assistants: object|null }>}
+ */
+
+
+exports.makeRagIndexTriggerAttributes = makeRagIndexTriggerAttributes;
+
+var findRagIndexTriggers = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(client) {
+    var _yield$client$collect, triggers, found, _iterator, _step, trigger;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return client.collection(TRIGGERS_DOCTYPE).find({
+              worker: RAG_INDEX_WORKER
+            });
+
+          case 2:
+            _yield$client$collect = _context.sent;
+            triggers = _yield$client$collect.data;
+            found = {
+              files: null,
+              assistants: null
+            };
+            _iterator = _createForOfIteratorHelper(triggers || []);
+            _context.prev = 6;
+
+            _iterator.s();
+
+          case 8:
+            if ((_step = _iterator.n()).done) {
+              _context.next = 15;
+              break;
+            }
+
+            trigger = _step.value;
+
+            if (!(trigger.type !== '@event')) {
+              _context.next = 12;
+              break;
+            }
+
+            return _context.abrupt("continue", 13);
+
+          case 12:
+            if (trigger.arguments === _queries.FILES_DOCTYPE && !found.files) {
+              found.files = trigger;
+            } else if (trigger.arguments === _queries.ASSISTANTS_DOCTYPE && !found.assistants) {
+              found.assistants = trigger;
+            }
+
+          case 13:
+            _context.next = 8;
+            break;
+
+          case 15:
+            _context.next = 20;
+            break;
+
+          case 17:
+            _context.prev = 17;
+            _context.t0 = _context["catch"](6);
+
+            _iterator.e(_context.t0);
+
+          case 20:
+            _context.prev = 20;
+
+            _iterator.f();
+
+            return _context.finish(20);
+
+          case 23:
+            return _context.abrupt("return", found);
+
+          case 24:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[6, 17, 20, 23]]);
+  }));
+
+  return function findRagIndexTriggers(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+/**
+ * Gives the root folder to every assistant without a knowledge base
+ * folder (the rule is permanent: an assistant always has one). A conflict
+ * on one assistant means another session did it: skipped.
+ * @returns {Promise<string[]>} The ids of the migrated assistants.
+ */
+
+
+exports.findRagIndexTriggers = findRagIndexTriggers;
+
+var migrateAssistantsWithoutFolder = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(client) {
+    var migrated, _buildAllAssistantsQu, definition, options, assistants, _iterator2, _step2, assistant, knowledgeBase;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            migrated = [];
+            _buildAllAssistantsQu = (0, _queries.buildAllAssistantsQuery)(), definition = _buildAllAssistantsQu.definition, options = _buildAllAssistantsQu.options;
+            _context2.next = 4;
+            return client.queryAll(definition(), options);
+
+          case 4:
+            assistants = _context2.sent;
+            _iterator2 = _createForOfIteratorHelper(assistants);
+            _context2.prev = 6;
+
+            _iterator2.s();
+
+          case 8:
+            if ((_step2 = _iterator2.n()).done) {
+              _context2.next = 25;
+              break;
+            }
+
+            assistant = _step2.value;
+            knowledgeBase = (0, _knowledgeBase.withRootFolderIfMissing)(assistant.knowledgeBase);
+
+            if (!(knowledgeBase === assistant.knowledgeBase)) {
+              _context2.next = 13;
+              break;
+            }
+
+            return _context2.abrupt("continue", 23);
+
+          case 13:
+            _context2.prev = 13;
+            _context2.next = 16;
+            return client.save(_objectSpread(_objectSpread({}, assistant), {}, {
+              knowledgeBase: knowledgeBase
+            }));
+
+          case 16:
+            migrated.push(assistant._id);
+            _context2.next = 23;
+            break;
+
+          case 19:
+            _context2.prev = 19;
+            _context2.t0 = _context2["catch"](13);
+
+            if (!((_context2.t0 === null || _context2.t0 === void 0 ? void 0 : _context2.t0.status) !== 409)) {
+              _context2.next = 23;
+              break;
+            }
+
+            throw _context2.t0;
+
+          case 23:
+            _context2.next = 8;
+            break;
+
+          case 25:
+            _context2.next = 30;
+            break;
+
+          case 27:
+            _context2.prev = 27;
+            _context2.t1 = _context2["catch"](6);
+
+            _iterator2.e(_context2.t1);
+
+          case 30:
+            _context2.prev = 30;
+
+            _iterator2.f();
+
+            return _context2.finish(30);
+
+          case 33:
+            return _context2.abrupt("return", migrated);
+
+          case 34:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[6, 27, 30, 33], [13, 19]]);
+  }));
+
+  return function migrateAssistantsWithoutFolder(_x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+/**
+ * Creates the missing triggers, pushing the `arguments` of each one
+ * created into `created` as it goes (so a failure halfway still reports
+ * what exists).
+ */
+
+
+exports.migrateAssistantsWithoutFolder = migrateAssistantsWithoutFolder;
+
+var ensureTriggers = /*#__PURE__*/function () {
+  var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(client, created) {
+    var _yield$findRagIndexTr, files, assistants, triggers, _yield$triggers$creat, trigger;
+
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 2;
+            return findRagIndexTriggers(client);
+
+          case 2:
+            _yield$findRagIndexTr = _context3.sent;
+            files = _yield$findRagIndexTr.files;
+            assistants = _yield$findRagIndexTr.assistants;
+            triggers = client.collection(TRIGGERS_DOCTYPE);
+
+            if (assistants) {
+              _context3.next = 10;
+              break;
+            }
+
+            _context3.next = 9;
+            return triggers.create(makeRagIndexTriggerAttributes(_queries.ASSISTANTS_DOCTYPE));
+
+          case 9:
+            created.push(_queries.ASSISTANTS_DOCTYPE);
+
+          case 10:
+            if (files) {
+              _context3.next = 26;
+              break;
+            }
+
+            _context3.next = 13;
+            return triggers.create(makeRagIndexTriggerAttributes(_queries.FILES_DOCTYPE));
+
+          case 13:
+            _yield$triggers$creat = _context3.sent;
+            trigger = _yield$triggers$creat.data;
+            _context3.prev = 15;
+            _context3.next = 18;
+            return triggers.launch(trigger);
+
+          case 18:
+            _context3.next = 25;
+            break;
+
+          case 20:
+            _context3.prev = 20;
+            _context3.t0 = _context3["catch"](15);
+            _context3.next = 24;
+            return triggers.destroy(trigger).catch(function () {});
+
+          case 24:
+            throw _context3.t0;
+
+          case 25:
+            created.push(_queries.FILES_DOCTYPE);
+
+          case 26:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[15, 20]]);
+  }));
+
+  return function ensureTriggers(_x3, _x4) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * Makes the instance ready for the assistants-driven indexing: the files
+ * and assistants triggers exist (the files one is launched when created),
+ * and every assistant has a knowledge base folder. Idempotent and never throws: an app calls it once
+ * per session at startup. On a stack that still reserves the worker the
+ * trigger creation answers 403: logged, the assistants keep working with
+ * the stack's legacy indexing.
+ * @param {import('cozy-client').CozyClient} client - The cozy client.
+ * @returns {Promise<{triggers: string[], migrated: string[], errors: Error[]}>}
+ * The `arguments` of the triggers created, the ids of the migrated
+ * assistants, and the failures.
+ */
+
+
+var setupRagIndexing = /*#__PURE__*/function () {
+  var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(client) {
+    var result;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            result = {
+              triggers: [],
+              migrated: [],
+              errors: []
+            };
+            _context4.prev = 1;
+            _context4.next = 4;
+            return ensureTriggers(client, result.triggers);
+
+          case 4:
+            _context4.next = 10;
+            break;
+
+          case 6:
+            _context4.prev = 6;
+            _context4.t0 = _context4["catch"](1);
+            warn('cannot set up the rag-index triggers', _context4.t0);
+            result.errors.push(_context4.t0);
+
+          case 10:
+            _context4.prev = 10;
+            _context4.next = 13;
+            return migrateAssistantsWithoutFolder(client);
+
+          case 13:
+            result.migrated = _context4.sent;
+            _context4.next = 20;
+            break;
+
+          case 16:
+            _context4.prev = 16;
+            _context4.t1 = _context4["catch"](10);
+            warn('cannot migrate the assistants without folder', _context4.t1);
+            result.errors.push(_context4.t1);
+
+          case 20:
+            return _context4.abrupt("return", result);
+
+          case 21:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[1, 6], [10, 16]]);
+  }));
+
+  return function setupRagIndexing(_x5) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+
+exports.setupRagIndexing = setupRagIndexing;

package/dist/components/KnowledgeBase/ragIndexing.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/KnowledgeBase/ragIndexing.spec.js

@@ -0,0 +1,268 @@
+import { Q } from 'cozy-client'
+
+import { ROOT_DIR_ID } from './knowledgeBase'
+import {
+  RAG_INDEX_FILES_DEBOUNCE,
+  findRagIndexTriggers,
+  makeRagIndexTriggerAttributes,
+  migrateAssistantsWithoutFolder,
+  setupRagIndexing
+} from './ragIndexing'
+
+const FILES = 'io.cozy.files'
+const ASSISTANTS = 'io.cozy.ai.chat.assistants'
+
+const filesTrigger = {
+  _id: 'trigger-files',
+  _type: 'io.cozy.triggers',
+  type: '@event',
+  worker: 'rag-index',
+  arguments: FILES,
+  debounce: '30s',
+  message: { doctype: FILES }
+}
+const assistantsTrigger = {
+  _id: 'trigger-assistants',
+  _type: 'io.cozy.triggers',
+  type: '@event',
+  worker: 'rag-index',
+  arguments: ASSISTANTS,
+  message: { doctype: FILES }
+}
+const cronFilesTrigger = {
+  _id: 'trigger-cron-files',
+  _type: 'io.cozy.triggers',
+  type: '@cron',
+  worker: 'rag-index',
+  arguments: FILES,
+  message: { doctype: FILES }
+}
+
+const makeClient = ({ triggers = [], assistants = [] } = {}) => {
+  const triggersCollection = {
+    find: jest.fn().mockResolvedValue({ data: triggers }),
+    create: jest.fn(async attributes => ({
+      data: { _id: `created-${attributes.arguments}`, ...attributes }
+    })),
+    launch: jest.fn().mockResolvedValue({ data: { _id: 'job-1' } }),
+    destroy: jest.fn(async trigger => ({ data: trigger }))
+  }
+  const client = {
+    collection: jest.fn(doctype => {
+      if (doctype === 'io.cozy.triggers') return triggersCollection
+      throw new Error(`unexpected collection ${doctype}`)
+    }),
+    queryAll: jest.fn(async () => assistants),
+    save: jest.fn(async doc => ({ data: doc }))
+  }
+  return { client, triggersCollection }
+}
+
+describe('makeRagIndexTriggerAttributes', () => {
+  it('debounces the files trigger only', () => {
+    expect(makeRagIndexTriggerAttributes(FILES)).toEqual({
+      type: '@event',
+      arguments: FILES,
+      debounce: RAG_INDEX_FILES_DEBOUNCE,
+      worker: 'rag-index',
+      message: { doctype: FILES }
+    })
+    expect(makeRagIndexTriggerAttributes(ASSISTANTS)).toEqual({
+      type: '@event',
+      arguments: ASSISTANTS,
+      worker: 'rag-index',
+      message: { doctype: FILES }
+    })
+    expect(RAG_INDEX_FILES_DEBOUNCE).toBe('30s')
+  })
+})
+
+describe('findRagIndexTriggers', () => {
+  it('sorts the triggers by kind', async () => {
+    const { client, triggersCollection } = makeClient({
+      triggers: [filesTrigger, assistantsTrigger]
+    })
+    const found = await findRagIndexTriggers(client)
+    expect(triggersCollection.find).toHaveBeenCalledWith({
+      worker: 'rag-index'
+    })
+    expect(found.files).toBe(filesTrigger)
+    expect(found.assistants).toBe(assistantsTrigger)
+  })
+
+  it('returns nulls when there is nothing', async () => {
+    const { client } = makeClient()
+    expect(await findRagIndexTriggers(client)).toEqual({
+      files: null,
+      assistants: null
+    })
+  })
+
+  it('ignores a rag-index trigger that is not an @event trigger', async () => {
+    const { client } = makeClient({ triggers: [cronFilesTrigger] })
+    const found = await findRagIndexTriggers(client)
+    expect(found.files).toBeNull()
+    expect(found.assistants).toBeNull()
+  })
+})
+
+describe('migrateAssistantsWithoutFolder', () => {
+  it('appends the root entry to assistants without folder, keeping other entries', async () => {
+    const { client } = makeClient({
+      assistants: [
+        {
+          _id: 'a1',
+          _type: ASSISTANTS,
+          knowledgeBase: [{ doctype: 'io.cozy.email' }]
+        },
+        {
+          _id: 'a2',
+          _type: ASSISTANTS,
+          knowledgeBase: [{ doctype: FILES, dirId: 'd' }]
+        },
+        { _id: 'a3', _type: ASSISTANTS }
+      ]
+    })
+    const migrated = await migrateAssistantsWithoutFolder(client)
+    expect(migrated).toEqual(['a1', 'a3'])
+    expect(client.queryAll).toHaveBeenCalledWith(Q(ASSISTANTS).limitBy(1000), {
+      as: `${ASSISTANTS}/all`
+    })
+    expect(client.save).toHaveBeenCalledTimes(2)
+    expect(client.save).toHaveBeenCalledWith({
+      _id: 'a1',
+      _type: ASSISTANTS,
+      knowledgeBase: [
+        { doctype: 'io.cozy.email' },
+        { doctype: FILES, dirId: ROOT_DIR_ID }
+      ]
+    })
+    expect(client.save).toHaveBeenCalledWith({
+      _id: 'a3',
+      _type: ASSISTANTS,
+      knowledgeBase: [{ doctype: FILES, dirId: ROOT_DIR_ID }]
+    })
+  })
+
+  it('ignores a conflict on one assistant and goes on', async () => {
+    const { client } = makeClient({
+      assistants: [
+        { _id: 'a1', _type: ASSISTANTS },
+        { _id: 'a2', _type: ASSISTANTS }
+      ]
+    })
+    client.save.mockImplementationOnce(async () => {
+      throw Object.assign(new Error('conflict'), { status: 409 })
+    })
+    expect(await migrateAssistantsWithoutFolder(client)).toEqual(['a2'])
+  })
+})
+
+describe('setupRagIndexing', () => {
+  let warn
+  beforeEach(() => {
+    warn = jest.spyOn(console, 'warn').mockImplementation(() => {})
+  })
+  afterEach(() => warn.mockRestore())
+
+  it('creates the missing triggers and launches the files one', async () => {
+    const { client, triggersCollection } = makeClient({
+      triggers: [assistantsTrigger]
+    })
+    const result = await setupRagIndexing(client)
+
+    expect(triggersCollection.create).toHaveBeenCalledTimes(1)
+    expect(triggersCollection.create).toHaveBeenCalledWith(
+      makeRagIndexTriggerAttributes(FILES)
+    )
+    expect(triggersCollection.launch).toHaveBeenCalledTimes(1)
+    expect(triggersCollection.launch.mock.calls[0][0]._id).toBe(
+      'created-io.cozy.files'
+    )
+    expect(result).toEqual({ triggers: [FILES], migrated: [], errors: [] })
+  })
+
+  it('removes the files trigger it could not launch, keeping the assistants one', async () => {
+    const { client, triggersCollection } = makeClient()
+    const launchError = new Error('launch failed')
+    triggersCollection.launch.mockRejectedValue(launchError)
+
+    const result = await setupRagIndexing(client)
+
+    expect(triggersCollection.destroy).toHaveBeenCalledTimes(1)
+    expect(triggersCollection.destroy.mock.calls[0][0]._id).toBe(
+      'created-io.cozy.files'
+    )
+    expect(result.triggers).toEqual([ASSISTANTS])
+    expect(result.errors).toEqual([launchError])
+  })
+
+  it('creates the files trigger when the existing one is not an @event trigger', async () => {
+    const { client, triggersCollection } = makeClient({
+      triggers: [cronFilesTrigger, assistantsTrigger]
+    })
+    const result = await setupRagIndexing(client)
+
+    expect(triggersCollection.create).toHaveBeenCalledWith(
+      makeRagIndexTriggerAttributes(FILES)
+    )
+    expect(result.triggers).toEqual([FILES])
+  })
+
+  it('creates the assistants trigger without launching it', async () => {
+    const { client, triggersCollection } = makeClient({
+      triggers: [filesTrigger]
+    })
+    const result = await setupRagIndexing(client)
+    expect(triggersCollection.create).toHaveBeenCalledWith(
+      makeRagIndexTriggerAttributes(ASSISTANTS)
+    )
+    expect(triggersCollection.launch).not.toHaveBeenCalled()
+    expect(result.triggers).toEqual([ASSISTANTS])
+  })
+
+  it('touches nothing when both triggers exist', async () => {
+    const { client, triggersCollection } = makeClient({
+      triggers: [filesTrigger, assistantsTrigger]
+    })
+    const result = await setupRagIndexing(client)
+    expect(triggersCollection.create).not.toHaveBeenCalled()
+    expect(result).toEqual({ triggers: [], migrated: [], errors: [] })
+  })
+
+  it('migrates the assistants without folder', async () => {
+    const { client } = makeClient({
+      triggers: [filesTrigger, assistantsTrigger],
+      assistants: [{ _id: 'a1', _type: ASSISTANTS }]
+    })
+    const result = await setupRagIndexing(client)
+    expect(result.migrated).toEqual(['a1'])
+    expect(client.save).toHaveBeenCalledTimes(1)
+  })
+
+  it('logs a 403 from an older stack and still migrates', async () => {
+    const { client, triggersCollection } = makeClient({
+      assistants: [{ _id: 'a1', _type: ASSISTANTS }]
+    })
+    triggersCollection.create.mockRejectedValue(
+      Object.assign(new Error('forbidden'), { status: 403 })
+    )
+    const result = await setupRagIndexing(client)
+    expect(result.triggers).toEqual([])
+    // The first failing creation aborts the trigger setup: one error.
+    expect(result.errors).toHaveLength(1)
+    expect(result.errors[0].status).toBe(403)
+    expect(result.migrated).toEqual(['a1'])
+    expect(warn).toHaveBeenCalled()
+  })
+
+  it('never throws, even when the listing fails', async () => {
+    const { client, triggersCollection } = makeClient()
+    triggersCollection.find.mockRejectedValue(new Error('down'))
+    const result = await setupRagIndexing(client)
+    expect(result.triggers).toEqual([])
+    expect(result.migrated).toEqual([])
+    expect(result.errors.map(e => e.message)).toEqual(['down'])
+    expect(triggersCollection.create).not.toHaveBeenCalled()
+  })
+})

package/dist/components/KnowledgeBase/useDefaultAssistantId.d.ts

@@ -0,0 +1 @@
+export function useDefaultAssistantId(): string | null | undefined;