@arabold/docs-mcp-server 1.10.0 → 1.12.0

package/dist/EmbeddingFactory-6UEXNF44.js

@@ -1,1177 +0,0 @@
-import {
-  DimensionError,
-  VECTOR_DIMENSION,
-  __commonJS,
-  __toESM
-} from "./chunk-YCXNASA6.js";
-
-// node_modules/retry/lib/retry_operation.js
-var require_retry_operation = __commonJS({
-  "node_modules/retry/lib/retry_operation.js"(exports, module) {
-    "use strict";
-    function RetryOperation(timeouts, options) {
-      if (typeof options === "boolean") {
-        options = { forever: options };
-      }
-      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
-      this._timeouts = timeouts;
-      this._options = options || {};
-      this._maxRetryTime = options && options.maxRetryTime || Infinity;
-      this._fn = null;
-      this._errors = [];
-      this._attempts = 1;
-      this._operationTimeout = null;
-      this._operationTimeoutCb = null;
-      this._timeout = null;
-      this._operationStart = null;
-      this._timer = null;
-      if (this._options.forever) {
-        this._cachedTimeouts = this._timeouts.slice(0);
-      }
-    }
-    module.exports = RetryOperation;
-    RetryOperation.prototype.reset = function() {
-      this._attempts = 1;
-      this._timeouts = this._originalTimeouts.slice(0);
-    };
-    RetryOperation.prototype.stop = function() {
-      if (this._timeout) {
-        clearTimeout(this._timeout);
-      }
-      if (this._timer) {
-        clearTimeout(this._timer);
-      }
-      this._timeouts = [];
-      this._cachedTimeouts = null;
-    };
-    RetryOperation.prototype.retry = function(err) {
-      if (this._timeout) {
-        clearTimeout(this._timeout);
-      }
-      if (!err) {
-        return false;
-      }
-      var currentTime = (/* @__PURE__ */ new Date()).getTime();
-      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
-        this._errors.push(err);
-        this._errors.unshift(new Error("RetryOperation timeout occurred"));
-        return false;
-      }
-      this._errors.push(err);
-      var timeout = this._timeouts.shift();
-      if (timeout === void 0) {
-        if (this._cachedTimeouts) {
-          this._errors.splice(0, this._errors.length - 1);
-          timeout = this._cachedTimeouts.slice(-1);
-        } else {
-          return false;
-        }
-      }
-      var self = this;
-      this._timer = setTimeout(function() {
-        self._attempts++;
-        if (self._operationTimeoutCb) {
-          self._timeout = setTimeout(function() {
-            self._operationTimeoutCb(self._attempts);
-          }, self._operationTimeout);
-          if (self._options.unref) {
-            self._timeout.unref();
-          }
-        }
-        self._fn(self._attempts);
-      }, timeout);
-      if (this._options.unref) {
-        this._timer.unref();
-      }
-      return true;
-    };
-    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
-      this._fn = fn;
-      if (timeoutOps) {
-        if (timeoutOps.timeout) {
-          this._operationTimeout = timeoutOps.timeout;
-        }
-        if (timeoutOps.cb) {
-          this._operationTimeoutCb = timeoutOps.cb;
-        }
-      }
-      var self = this;
-      if (this._operationTimeoutCb) {
-        this._timeout = setTimeout(function() {
-          self._operationTimeoutCb();
-        }, self._operationTimeout);
-      }
-      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
-      this._fn(this._attempts);
-    };
-    RetryOperation.prototype.try = function(fn) {
-      console.log("Using RetryOperation.try() is deprecated");
-      this.attempt(fn);
-    };
-    RetryOperation.prototype.start = function(fn) {
-      console.log("Using RetryOperation.start() is deprecated");
-      this.attempt(fn);
-    };
-    RetryOperation.prototype.start = RetryOperation.prototype.try;
-    RetryOperation.prototype.errors = function() {
-      return this._errors;
-    };
-    RetryOperation.prototype.attempts = function() {
-      return this._attempts;
-    };
-    RetryOperation.prototype.mainError = function() {
-      if (this._errors.length === 0) {
-        return null;
-      }
-      var counts = {};
-      var mainError = null;
-      var mainErrorCount = 0;
-      for (var i = 0; i < this._errors.length; i++) {
-        var error = this._errors[i];
-        var message = error.message;
-        var count = (counts[message] || 0) + 1;
-        counts[message] = count;
-        if (count >= mainErrorCount) {
-          mainError = error;
-          mainErrorCount = count;
-        }
-      }
-      return mainError;
-    };
-  }
-});
-
-// node_modules/retry/lib/retry.js
-var require_retry = __commonJS({
-  "node_modules/retry/lib/retry.js"(exports) {
-    "use strict";
-    var RetryOperation = require_retry_operation();
-    exports.operation = function(options) {
-      var timeouts = exports.timeouts(options);
-      return new RetryOperation(timeouts, {
-        forever: options && (options.forever || options.retries === Infinity),
-        unref: options && options.unref,
-        maxRetryTime: options && options.maxRetryTime
-      });
-    };
-    exports.timeouts = function(options) {
-      if (options instanceof Array) {
-        return [].concat(options);
-      }
-      var opts = {
-        retries: 10,
-        factor: 2,
-        minTimeout: 1 * 1e3,
-        maxTimeout: Infinity,
-        randomize: false
-      };
-      for (var key in options) {
-        opts[key] = options[key];
-      }
-      if (opts.minTimeout > opts.maxTimeout) {
-        throw new Error("minTimeout is greater than maxTimeout");
-      }
-      var timeouts = [];
-      for (var i = 0; i < opts.retries; i++) {
-        timeouts.push(this.createTimeout(i, opts));
-      }
-      if (options && options.forever && !timeouts.length) {
-        timeouts.push(this.createTimeout(i, opts));
-      }
-      timeouts.sort(function(a, b) {
-        return a - b;
-      });
-      return timeouts;
-    };
-    exports.createTimeout = function(attempt, opts) {
-      var random = opts.randomize ? Math.random() + 1 : 1;
-      var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
-      timeout = Math.min(timeout, opts.maxTimeout);
-      return timeout;
-    };
-    exports.wrap = function(obj, options, methods) {
-      if (options instanceof Array) {
-        methods = options;
-        options = null;
-      }
-      if (!methods) {
-        methods = [];
-        for (var key in obj) {
-          if (typeof obj[key] === "function") {
-            methods.push(key);
-          }
-        }
-      }
-      for (var i = 0; i < methods.length; i++) {
-        var method = methods[i];
-        var original = obj[method];
-        obj[method] = function retryWrapper(original2) {
-          var op = exports.operation(options);
-          var args = Array.prototype.slice.call(arguments, 1);
-          var callback = args.pop();
-          args.push(function(err) {
-            if (op.retry(err)) {
-              return;
-            }
-            if (err) {
-              arguments[0] = op.mainError();
-            }
-            callback.apply(this, arguments);
-          });
-          op.attempt(function() {
-            original2.apply(obj, args);
-          });
-        }.bind(obj, original);
-        obj[method].options = options;
-      }
-    };
-  }
-});
-
-// node_modules/retry/index.js
-var require_retry2 = __commonJS({
-  "node_modules/retry/index.js"(exports, module) {
-    "use strict";
-    module.exports = require_retry();
-  }
-});
-
-// node_modules/p-retry/index.js
-var require_p_retry = __commonJS({
-  "node_modules/p-retry/index.js"(exports, module) {
-    "use strict";
-    var retry = require_retry2();
-    var networkErrorMsgs = [
-      "Failed to fetch",
-      // Chrome
-      "NetworkError when attempting to fetch resource.",
-      // Firefox
-      "The Internet connection appears to be offline.",
-      // Safari
-      "Network request failed"
-      // `cross-fetch`
-    ];
-    var AbortError = class extends Error {
-      constructor(message) {
-        super();
-        if (message instanceof Error) {
-          this.originalError = message;
-          ({ message } = message);
-        } else {
-          this.originalError = new Error(message);
-          this.originalError.stack = this.stack;
-        }
-        this.name = "AbortError";
-        this.message = message;
-      }
-    };
-    var decorateErrorWithCounts = (error, attemptNumber, options) => {
-      const retriesLeft = options.retries - (attemptNumber - 1);
-      error.attemptNumber = attemptNumber;
-      error.retriesLeft = retriesLeft;
-      return error;
-    };
-    var isNetworkError = (errorMessage) => networkErrorMsgs.includes(errorMessage);
-    var pRetry2 = (input, options) => new Promise((resolve, reject) => {
-      options = {
-        onFailedAttempt: () => {
-        },
-        retries: 10,
-        ...options
-      };
-      const operation = retry.operation(options);
-      operation.attempt(async (attemptNumber) => {
-        try {
-          resolve(await input(attemptNumber));
-        } catch (error) {
-          if (!(error instanceof Error)) {
-            reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
-            return;
-          }
-          if (error instanceof AbortError) {
-            operation.stop();
-            reject(error.originalError);
-          } else if (error instanceof TypeError && !isNetworkError(error.message)) {
-            operation.stop();
-            reject(error);
-          } else {
-            decorateErrorWithCounts(error, attemptNumber, options);
-            try {
-              await options.onFailedAttempt(error);
-            } catch (error2) {
-              reject(error2);
-              return;
-            }
-            if (!operation.retry(error)) {
-              reject(operation.mainError());
-            }
-          }
-        }
-      });
-    });
-    module.exports = pRetry2;
-    module.exports.default = pRetry2;
-    module.exports.AbortError = AbortError;
-  }
-});
-
-// node_modules/eventemitter3/index.js
-var require_eventemitter3 = __commonJS({
-  "node_modules/eventemitter3/index.js"(exports, module) {
-    "use strict";
-    var has = Object.prototype.hasOwnProperty;
-    var prefix = "~";
-    function Events() {
-    }
-    if (Object.create) {
-      Events.prototype = /* @__PURE__ */ Object.create(null);
-      if (!new Events().__proto__) prefix = false;
-    }
-    function EE(fn, context, once) {
-      this.fn = fn;
-      this.context = context;
-      this.once = once || false;
-    }
-    function addListener(emitter, event, fn, context, once) {
-      if (typeof fn !== "function") {
-        throw new TypeError("The listener must be a function");
-      }
-      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
-      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
-      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
-      else emitter._events[evt] = [emitter._events[evt], listener];
-      return emitter;
-    }
-    function clearEvent(emitter, evt) {
-      if (--emitter._eventsCount === 0) emitter._events = new Events();
-      else delete emitter._events[evt];
-    }
-    function EventEmitter() {
-      this._events = new Events();
-      this._eventsCount = 0;
-    }
-    EventEmitter.prototype.eventNames = function eventNames() {
-      var names = [], events, name;
-      if (this._eventsCount === 0) return names;
-      for (name in events = this._events) {
-        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
-      }
-      if (Object.getOwnPropertySymbols) {
-        return names.concat(Object.getOwnPropertySymbols(events));
-      }
-      return names;
-    };
-    EventEmitter.prototype.listeners = function listeners(event) {
-      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
-      if (!handlers) return [];
-      if (handlers.fn) return [handlers.fn];
-      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
-        ee[i] = handlers[i].fn;
-      }
-      return ee;
-    };
-    EventEmitter.prototype.listenerCount = function listenerCount(event) {
-      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
-      if (!listeners) return 0;
-      if (listeners.fn) return 1;
-      return listeners.length;
-    };
-    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
-      var evt = prefix ? prefix + event : event;
-      if (!this._events[evt]) return false;
-      var listeners = this._events[evt], len = arguments.length, args, i;
-      if (listeners.fn) {
-        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
-        switch (len) {
-          case 1:
-            return listeners.fn.call(listeners.context), true;
-          case 2:
-            return listeners.fn.call(listeners.context, a1), true;
-          case 3:
-            return listeners.fn.call(listeners.context, a1, a2), true;
-          case 4:
-            return listeners.fn.call(listeners.context, a1, a2, a3), true;
-          case 5:
-            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
-          case 6:
-            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
-        }
-        for (i = 1, args = new Array(len - 1); i < len; i++) {
-          args[i - 1] = arguments[i];
-        }
-        listeners.fn.apply(listeners.context, args);
-      } else {
-        var length = listeners.length, j;
-        for (i = 0; i < length; i++) {
-          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
-          switch (len) {
-            case 1:
-              listeners[i].fn.call(listeners[i].context);
-              break;
-            case 2:
-              listeners[i].fn.call(listeners[i].context, a1);
-              break;
-            case 3:
-              listeners[i].fn.call(listeners[i].context, a1, a2);
-              break;
-            case 4:
-              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
-              break;
-            default:
-              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
-                args[j - 1] = arguments[j];
-              }
-              listeners[i].fn.apply(listeners[i].context, args);
-          }
-        }
-      }
-      return true;
-    };
-    EventEmitter.prototype.on = function on(event, fn, context) {
-      return addListener(this, event, fn, context, false);
-    };
-    EventEmitter.prototype.once = function once(event, fn, context) {
-      return addListener(this, event, fn, context, true);
-    };
-    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
-      var evt = prefix ? prefix + event : event;
-      if (!this._events[evt]) return this;
-      if (!fn) {
-        clearEvent(this, evt);
-        return this;
-      }
-      var listeners = this._events[evt];
-      if (listeners.fn) {
-        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
-          clearEvent(this, evt);
-        }
-      } else {
-        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
-          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
-            events.push(listeners[i]);
-          }
-        }
-        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
-        else clearEvent(this, evt);
-      }
-      return this;
-    };
-    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
-      var evt;
-      if (event) {
-        evt = prefix ? prefix + event : event;
-        if (this._events[evt]) clearEvent(this, evt);
-      } else {
-        this._events = new Events();
-        this._eventsCount = 0;
-      }
-      return this;
-    };
-    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
-    EventEmitter.prefixed = prefix;
-    EventEmitter.EventEmitter = EventEmitter;
-    if ("undefined" !== typeof module) {
-      module.exports = EventEmitter;
-    }
-  }
-});
-
-// node_modules/p-finally/index.js
-var require_p_finally = __commonJS({
-  "node_modules/p-finally/index.js"(exports, module) {
-    "use strict";
-    module.exports = (promise, onFinally) => {
-      onFinally = onFinally || (() => {
-      });
-      return promise.then(
-        (val) => new Promise((resolve) => {
-          resolve(onFinally());
-        }).then(() => val),
-        (err) => new Promise((resolve) => {
-          resolve(onFinally());
-        }).then(() => {
-          throw err;
-        })
-      );
-    };
-  }
-});
-
-// node_modules/p-timeout/index.js
-var require_p_timeout = __commonJS({
-  "node_modules/p-timeout/index.js"(exports, module) {
-    "use strict";
-    var pFinally = require_p_finally();
-    var TimeoutError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "TimeoutError";
-      }
-    };
-    var pTimeout = (promise, milliseconds, fallback) => new Promise((resolve, reject) => {
-      if (typeof milliseconds !== "number" || milliseconds < 0) {
-        throw new TypeError("Expected `milliseconds` to be a positive number");
-      }
-      if (milliseconds === Infinity) {
-        resolve(promise);
-        return;
-      }
-      const timer = setTimeout(() => {
-        if (typeof fallback === "function") {
-          try {
-            resolve(fallback());
-          } catch (error) {
-            reject(error);
-          }
-          return;
-        }
-        const message = typeof fallback === "string" ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
-        const timeoutError = fallback instanceof Error ? fallback : new TimeoutError(message);
-        if (typeof promise.cancel === "function") {
-          promise.cancel();
-        }
-        reject(timeoutError);
-      }, milliseconds);
-      pFinally(
-        // eslint-disable-next-line promise/prefer-await-to-then
-        promise.then(resolve, reject),
-        () => {
-          clearTimeout(timer);
-        }
-      );
-    });
-    module.exports = pTimeout;
-    module.exports.default = pTimeout;
-    module.exports.TimeoutError = TimeoutError;
-  }
-});
-
-// node_modules/p-queue/dist/lower-bound.js
-var require_lower_bound = __commonJS({
-  "node_modules/p-queue/dist/lower-bound.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    function lowerBound(array, value, comparator) {
-      let first = 0;
-      let count = array.length;
-      while (count > 0) {
-        const step = count / 2 | 0;
-        let it = first + step;
-        if (comparator(array[it], value) <= 0) {
-          first = ++it;
-          count -= step + 1;
-        } else {
-          count = step;
-        }
-      }
-      return first;
-    }
-    exports.default = lowerBound;
-  }
-});
-
-// node_modules/p-queue/dist/priority-queue.js
-var require_priority_queue = __commonJS({
-  "node_modules/p-queue/dist/priority-queue.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    var lower_bound_1 = require_lower_bound();
-    var PriorityQueue = class {
-      constructor() {
-        this._queue = [];
-      }
-      enqueue(run, options) {
-        options = Object.assign({ priority: 0 }, options);
-        const element = {
-          priority: options.priority,
-          run
-        };
-        if (this.size && this._queue[this.size - 1].priority >= options.priority) {
-          this._queue.push(element);
-          return;
-        }
-        const index = lower_bound_1.default(this._queue, element, (a, b) => b.priority - a.priority);
-        this._queue.splice(index, 0, element);
-      }
-      dequeue() {
-        const item = this._queue.shift();
-        return item === null || item === void 0 ? void 0 : item.run;
-      }
-      filter(options) {
-        return this._queue.filter((element) => element.priority === options.priority).map((element) => element.run);
-      }
-      get size() {
-        return this._queue.length;
-      }
-    };
-    exports.default = PriorityQueue;
-  }
-});
-
-// node_modules/p-queue/dist/index.js
-var require_dist = __commonJS({
-  "node_modules/p-queue/dist/index.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    var EventEmitter = require_eventemitter3();
-    var p_timeout_1 = require_p_timeout();
-    var priority_queue_1 = require_priority_queue();
-    var empty = () => {
-    };
-    var timeoutError = new p_timeout_1.TimeoutError();
-    var PQueue = class extends EventEmitter {
-      constructor(options) {
-        var _a, _b, _c, _d;
-        super();
-        this._intervalCount = 0;
-        this._intervalEnd = 0;
-        this._pendingCount = 0;
-        this._resolveEmpty = empty;
-        this._resolveIdle = empty;
-        options = Object.assign({ carryoverConcurrencyCount: false, intervalCap: Infinity, interval: 0, concurrency: Infinity, autoStart: true, queueClass: priority_queue_1.default }, options);
-        if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
-          throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${(_b = (_a = options.intervalCap) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ""}\` (${typeof options.intervalCap})`);
-        }
-        if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
-          throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${(_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : ""}\` (${typeof options.interval})`);
-        }
-        this._carryoverConcurrencyCount = options.carryoverConcurrencyCount;
-        this._isIntervalIgnored = options.intervalCap === Infinity || options.interval === 0;
-        this._intervalCap = options.intervalCap;
-        this._interval = options.interval;
-        this._queue = new options.queueClass();
-        this._queueClass = options.queueClass;
-        this.concurrency = options.concurrency;
-        this._timeout = options.timeout;
-        this._throwOnTimeout = options.throwOnTimeout === true;
-        this._isPaused = options.autoStart === false;
-      }
-      get _doesIntervalAllowAnother() {
-        return this._isIntervalIgnored || this._intervalCount < this._intervalCap;
-      }
-      get _doesConcurrentAllowAnother() {
-        return this._pendingCount < this._concurrency;
-      }
-      _next() {
-        this._pendingCount--;
-        this._tryToStartAnother();
-        this.emit("next");
-      }
-      _resolvePromises() {
-        this._resolveEmpty();
-        this._resolveEmpty = empty;
-        if (this._pendingCount === 0) {
-          this._resolveIdle();
-          this._resolveIdle = empty;
-          this.emit("idle");
-        }
-      }
-      _onResumeInterval() {
-        this._onInterval();
-        this._initializeIntervalIfNeeded();
-        this._timeoutId = void 0;
-      }
-      _isIntervalPaused() {
-        const now = Date.now();
-        if (this._intervalId === void 0) {
-          const delay = this._intervalEnd - now;
-          if (delay < 0) {
-            this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
-          } else {
-            if (this._timeoutId === void 0) {
-              this._timeoutId = setTimeout(() => {
-                this._onResumeInterval();
-              }, delay);
-            }
-            return true;
-          }
-        }
-        return false;
-      }
-      _tryToStartAnother() {
-        if (this._queue.size === 0) {
-          if (this._intervalId) {
-            clearInterval(this._intervalId);
-          }
-          this._intervalId = void 0;
-          this._resolvePromises();
-          return false;
-        }
-        if (!this._isPaused) {
-          const canInitializeInterval = !this._isIntervalPaused();
-          if (this._doesIntervalAllowAnother && this._doesConcurrentAllowAnother) {
-            const job = this._queue.dequeue();
-            if (!job) {
-              return false;
-            }
-            this.emit("active");
-            job();
-            if (canInitializeInterval) {
-              this._initializeIntervalIfNeeded();
-            }
-            return true;
-          }
-        }
-        return false;
-      }
-      _initializeIntervalIfNeeded() {
-        if (this._isIntervalIgnored || this._intervalId !== void 0) {
-          return;
-        }
-        this._intervalId = setInterval(() => {
-          this._onInterval();
-        }, this._interval);
-        this._intervalEnd = Date.now() + this._interval;
-      }
-      _onInterval() {
-        if (this._intervalCount === 0 && this._pendingCount === 0 && this._intervalId) {
-          clearInterval(this._intervalId);
-          this._intervalId = void 0;
-        }
-        this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
-        this._processQueue();
-      }
-      /**
-      Executes all queued functions until it reaches the limit.
-      */
-      _processQueue() {
-        while (this._tryToStartAnother()) {
-        }
-      }
-      get concurrency() {
-        return this._concurrency;
-      }
-      set concurrency(newConcurrency) {
-        if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
-          throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
-        }
-        this._concurrency = newConcurrency;
-        this._processQueue();
-      }
-      /**
-      Adds a sync or async task to the queue. Always returns a promise.
-      */
-      async add(fn, options = {}) {
-        return new Promise((resolve, reject) => {
-          const run = async () => {
-            this._pendingCount++;
-            this._intervalCount++;
-            try {
-              const operation = this._timeout === void 0 && options.timeout === void 0 ? fn() : p_timeout_1.default(Promise.resolve(fn()), options.timeout === void 0 ? this._timeout : options.timeout, () => {
-                if (options.throwOnTimeout === void 0 ? this._throwOnTimeout : options.throwOnTimeout) {
-                  reject(timeoutError);
-                }
-                return void 0;
-              });
-              resolve(await operation);
-            } catch (error) {
-              reject(error);
-            }
-            this._next();
-          };
-          this._queue.enqueue(run, options);
-          this._tryToStartAnother();
-          this.emit("add");
-        });
-      }
-      /**
-          Same as `.add()`, but accepts an array of sync or async functions.
-      
-          @returns A promise that resolves when all functions are resolved.
-          */
-      async addAll(functions, options) {
-        return Promise.all(functions.map(async (function_) => this.add(function_, options)));
-      }
-      /**
-      Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
-      */
-      start() {
-        if (!this._isPaused) {
-          return this;
-        }
-        this._isPaused = false;
-        this._processQueue();
-        return this;
-      }
-      /**
-      Put queue execution on hold.
-      */
-      pause() {
-        this._isPaused = true;
-      }
-      /**
-      Clear the queue.
-      */
-      clear() {
-        this._queue = new this._queueClass();
-      }
-      /**
-          Can be called multiple times. Useful if you for example add additional items at a later time.
-      
-          @returns A promise that settles when the queue becomes empty.
-          */
-      async onEmpty() {
-        if (this._queue.size === 0) {
-          return;
-        }
-        return new Promise((resolve) => {
-          const existingResolve = this._resolveEmpty;
-          this._resolveEmpty = () => {
-            existingResolve();
-            resolve();
-          };
-        });
-      }
-      /**
-          The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
-      
-          @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
-          */
-      async onIdle() {
-        if (this._pendingCount === 0 && this._queue.size === 0) {
-          return;
-        }
-        return new Promise((resolve) => {
-          const existingResolve = this._resolveIdle;
-          this._resolveIdle = () => {
-            existingResolve();
-            resolve();
-          };
-        });
-      }
-      /**
-      Size of the queue.
-      */
-      get size() {
-        return this._queue.size;
-      }
-      /**
-          Size of the queue, filtered by the given options.
-      
-          For example, this can be used to find the number of items remaining in the queue with a specific priority level.
-          */
-      sizeBy(options) {
-        return this._queue.filter(options).length;
-      }
-      /**
-      Number of pending promises.
-      */
-      get pending() {
-        return this._pendingCount;
-      }
-      /**
-      Whether the queue is currently paused.
-      */
-      get isPaused() {
-        return this._isPaused;
-      }
-      get timeout() {
-        return this._timeout;
-      }
-      /**
-      Set the timeout for future operations.
-      */
-      set timeout(milliseconds) {
-        this._timeout = milliseconds;
-      }
-    };
-    exports.default = PQueue;
-  }
-});
-
-// src/store/embeddings/EmbeddingFactory.ts
-import { BedrockEmbeddings } from "@langchain/aws";
-import { GoogleGenerativeAIEmbeddings } from "@langchain/google-genai";
-import { VertexAIEmbeddings } from "@langchain/google-vertexai";
-import {
-  AzureOpenAIEmbeddings,
-  OpenAIEmbeddings
-} from "@langchain/openai";
-
-// node_modules/@langchain/core/dist/utils/async_caller.js
-var import_p_retry = __toESM(require_p_retry(), 1);
-var import_p_queue = __toESM(require_dist(), 1);
-var STATUS_NO_RETRY = [
-  400,
-  401,
-  402,
-  403,
-  404,
-  405,
-  406,
-  407,
-  409
-  // Conflict
-];
-var defaultFailedAttemptHandler = (error) => {
-  if (error.message.startsWith("Cancel") || error.message.startsWith("AbortError") || error.name === "AbortError") {
-    throw error;
-  }
-  if (error?.code === "ECONNABORTED") {
-    throw error;
-  }
-  const status = (
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    error?.response?.status ?? error?.status
-  );
-  if (status && STATUS_NO_RETRY.includes(+status)) {
-    throw error;
-  }
-  if (error?.error?.code === "insufficient_quota") {
-    const err = new Error(error?.message);
-    err.name = "InsufficientQuotaError";
-    throw err;
-  }
-};
-var AsyncCaller = class {
-  constructor(params) {
-    Object.defineProperty(this, "maxConcurrency", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "maxRetries", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "onFailedAttempt", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, "queue", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.maxConcurrency = params.maxConcurrency ?? Infinity;
-    this.maxRetries = params.maxRetries ?? 6;
-    this.onFailedAttempt = params.onFailedAttempt ?? defaultFailedAttemptHandler;
-    const PQueue = "default" in import_p_queue.default ? import_p_queue.default.default : import_p_queue.default;
-    this.queue = new PQueue({ concurrency: this.maxConcurrency });
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  call(callable, ...args) {
-    return this.queue.add(() => (0, import_p_retry.default)(() => callable(...args).catch((error) => {
-      if (error instanceof Error) {
-        throw error;
-      } else {
-        throw new Error(error);
-      }
-    }), {
-      onFailedAttempt: this.onFailedAttempt,
-      retries: this.maxRetries,
-      randomize: true
-      // If needed we can change some of the defaults here,
-      // but they're quite sensible.
-    }), { throwOnTimeout: true });
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  callWithOptions(options, callable, ...args) {
-    if (options.signal) {
-      return Promise.race([
-        this.call(callable, ...args),
-        new Promise((_, reject) => {
-          options.signal?.addEventListener("abort", () => {
-            reject(new Error("AbortError"));
-          });
-        })
-      ]);
-    }
-    return this.call(callable, ...args);
-  }
-  fetch(...args) {
-    return this.call(() => fetch(...args).then((res) => res.ok ? res : Promise.reject(res)));
-  }
-};
-
-// node_modules/@langchain/core/dist/embeddings.js
-var Embeddings = class {
-  constructor(params) {
-    Object.defineProperty(this, "caller", {
-      enumerable: true,
-      configurable: true,
-      writable: true,
-      value: void 0
-    });
-    this.caller = new AsyncCaller(params ?? {});
-  }
-};
-
-// src/store/embeddings/FixedDimensionEmbeddings.ts
-var FixedDimensionEmbeddings = class extends Embeddings {
-  constructor(embeddings, targetDimension, providerAndModel, allowTruncate = false) {
-    super({});
-    this.embeddings = embeddings;
-    this.targetDimension = targetDimension;
-    this.allowTruncate = allowTruncate;
-    const [providerOrModel, modelName] = providerAndModel.split(":");
-    this.provider = modelName ? providerOrModel : "openai";
-    this.model = modelName || providerOrModel;
-  }
-  provider;
-  model;
-  /**
-   * Normalize a vector to the target dimension by truncating (for MRL models) or padding.
-   * @throws {DimensionError} If vector is too large and provider doesn't support MRL
-   */
-  normalizeVector(vector) {
-    const dimension = vector.length;
-    if (dimension > this.targetDimension) {
-      if (this.allowTruncate) {
-        return vector.slice(0, this.targetDimension);
-      }
-      throw new DimensionError(
-        `${this.provider}:${this.model}`,
-        dimension,
-        this.targetDimension
-      );
-    }
-    if (dimension < this.targetDimension) {
-      return [...vector, ...new Array(this.targetDimension - dimension).fill(0)];
-    }
-    return vector;
-  }
-  async embedQuery(text) {
-    const vector = await this.embeddings.embedQuery(text);
-    return this.normalizeVector(vector);
-  }
-  async embedDocuments(documents) {
-    const vectors = await this.embeddings.embedDocuments(documents);
-    return vectors.map((vector) => this.normalizeVector(vector));
-  }
-};
-
-// src/store/embeddings/EmbeddingFactory.ts
-var UnsupportedProviderError = class extends Error {
-  constructor(provider) {
-    super(`Unsupported embedding provider: ${provider}`);
-    this.name = "UnsupportedProviderError";
-  }
-};
-var ModelConfigurationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ModelConfigurationError";
-  }
-};
-function createEmbeddingModel(providerAndModel) {
-  const [providerOrModel, modelName] = providerAndModel.split(":");
-  const provider = modelName ? providerOrModel : "openai";
-  const model = modelName || providerOrModel;
-  const baseConfig = { stripNewLines: true };
-  switch (provider) {
-    case "openai": {
-      const config = {
-        ...baseConfig,
-        modelName: model,
-        batchSize: 512
-        // OpenAI supports large batches
-      };
-      const baseURL = process.env.OPENAI_API_BASE;
-      if (baseURL) {
-        config.configuration = { baseURL };
-      }
-      return new OpenAIEmbeddings(config);
-    }
-    case "vertex": {
-      if (!process.env.GOOGLE_APPLICATION_CREDENTIALS) {
-        throw new ModelConfigurationError(
-          "GOOGLE_APPLICATION_CREDENTIALS environment variable is required for Google Cloud Vertex AI"
-        );
-      }
-      return new VertexAIEmbeddings({
-        ...baseConfig,
-        model
-        // e.g., "text-embedding-004"
-      });
-    }
-    case "gemini": {
-      if (!process.env.GOOGLE_API_KEY) {
-        throw new ModelConfigurationError(
-          "GOOGLE_API_KEY environment variable is required for Google AI (Gemini)"
-        );
-      }
-      const baseEmbeddings = new GoogleGenerativeAIEmbeddings({
-        ...baseConfig,
-        apiKey: process.env.GOOGLE_API_KEY,
-        model
-        // e.g., "gemini-embedding-exp-03-07"
-      });
-      return new FixedDimensionEmbeddings(
-        baseEmbeddings,
-        VECTOR_DIMENSION,
-        providerAndModel,
-        true
-      );
-    }
-    case "aws": {
-      const region = process.env.BEDROCK_AWS_REGION || process.env.AWS_REGION;
-      if (!region) {
-        throw new ModelConfigurationError(
-          "BEDROCK_AWS_REGION or AWS_REGION environment variable is required for AWS Bedrock"
-        );
-      }
-      if (!process.env.AWS_ACCESS_KEY_ID || !process.env.AWS_SECRET_ACCESS_KEY) {
-        throw new ModelConfigurationError(
-          "AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables are required for AWS Bedrock"
-        );
-      }
-      return new BedrockEmbeddings({
-        ...baseConfig,
-        model,
-        // e.g., "amazon.titan-embed-text-v1"
-        region,
-        credentials: {
-          accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-          secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-          sessionToken: process.env.AWS_SESSION_TOKEN
-        }
-      });
-    }
-    case "microsoft": {
-      if (!process.env.AZURE_OPENAI_API_KEY) {
-        throw new ModelConfigurationError(
-          "AZURE_OPENAI_API_KEY environment variable is required for Azure OpenAI"
-        );
-      }
-      if (!process.env.AZURE_OPENAI_API_INSTANCE_NAME) {
-        throw new ModelConfigurationError(
-          "AZURE_OPENAI_API_INSTANCE_NAME environment variable is required for Azure OpenAI"
-        );
-      }
-      if (!process.env.AZURE_OPENAI_API_DEPLOYMENT_NAME) {
-        throw new ModelConfigurationError(
-          "AZURE_OPENAI_API_DEPLOYMENT_NAME environment variable is required for Azure OpenAI"
-        );
-      }
-      if (!process.env.AZURE_OPENAI_API_VERSION) {
-        throw new ModelConfigurationError(
-          "AZURE_OPENAI_API_VERSION environment variable is required for Azure OpenAI"
-        );
-      }
-      return new AzureOpenAIEmbeddings({
-        ...baseConfig,
-        azureOpenAIApiKey: process.env.AZURE_OPENAI_API_KEY,
-        azureOpenAIApiInstanceName: process.env.AZURE_OPENAI_API_INSTANCE_NAME,
-        azureOpenAIApiDeploymentName: process.env.AZURE_OPENAI_API_DEPLOYMENT_NAME,
-        azureOpenAIApiVersion: process.env.AZURE_OPENAI_API_VERSION,
-        deploymentName: model
-      });
-    }
-    default:
-      throw new UnsupportedProviderError(provider);
-  }
-}
-export {
-  ModelConfigurationError,
-  UnsupportedProviderError,
-  createEmbeddingModel
-};
-//# sourceMappingURL=EmbeddingFactory-6UEXNF44.js.map