@botpress/cognitive 0.1.0

package/dist/index.mjs

@@ -0,0 +1,979 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/options.js
+var require_options = __commonJS({
+  "../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/options.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var defaultOptions = {
+      delayFirstAttempt: false,
+      jitter: "none",
+      maxDelay: Infinity,
+      numOfAttempts: 10,
+      retry: function() {
+        return true;
+      },
+      startingDelay: 100,
+      timeMultiple: 2
+    };
+    function getSanitizedOptions(options) {
+      var sanitized = __assign(__assign({}, defaultOptions), options);
+      if (sanitized.numOfAttempts < 1) {
+        sanitized.numOfAttempts = 1;
+      }
+      return sanitized;
+    }
+    exports.getSanitizedOptions = getSanitizedOptions;
+  }
+});
+
+// ../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/jitter/full/full.jitter.js
+var require_full_jitter = __commonJS({
+  "../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/jitter/full/full.jitter.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function fullJitter(delay) {
+      var jitteredDelay = Math.random() * delay;
+      return Math.round(jitteredDelay);
+    }
+    exports.fullJitter = fullJitter;
+  }
+});
+
+// ../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/jitter/no/no.jitter.js
+var require_no_jitter = __commonJS({
+  "../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/jitter/no/no.jitter.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function noJitter(delay) {
+      return delay;
+    }
+    exports.noJitter = noJitter;
+  }
+});
+
+// ../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/jitter/jitter.factory.js
+var require_jitter_factory = __commonJS({
+  "../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/jitter/jitter.factory.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var full_jitter_1 = require_full_jitter();
+    var no_jitter_1 = require_no_jitter();
+    function JitterFactory(options) {
+      switch (options.jitter) {
+        case "full":
+          return full_jitter_1.fullJitter;
+        case "none":
+        default:
+          return no_jitter_1.noJitter;
+      }
+    }
+    exports.JitterFactory = JitterFactory;
+  }
+});
+
+// ../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/delay/delay.base.js
+var require_delay_base = __commonJS({
+  "../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/delay/delay.base.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var jitter_factory_1 = require_jitter_factory();
+    var Delay = (
+      /** @class */
+      function() {
+        function Delay2(options) {
+          this.options = options;
+          this.attempt = 0;
+        }
+        Delay2.prototype.apply = function() {
+          var _this = this;
+          return new Promise(function(resolve) {
+            return setTimeout(resolve, _this.jitteredDelay);
+          });
+        };
+        Delay2.prototype.setAttemptNumber = function(attempt) {
+          this.attempt = attempt;
+        };
+        Object.defineProperty(Delay2.prototype, "jitteredDelay", {
+          get: function() {
+            var jitter = jitter_factory_1.JitterFactory(this.options);
+            return jitter(this.delay);
+          },
+          enumerable: true,
+          configurable: true
+        });
+        Object.defineProperty(Delay2.prototype, "delay", {
+          get: function() {
+            var constant = this.options.startingDelay;
+            var base = this.options.timeMultiple;
+            var power = this.numOfDelayedAttempts;
+            var delay = constant * Math.pow(base, power);
+            return Math.min(delay, this.options.maxDelay);
+          },
+          enumerable: true,
+          configurable: true
+        });
+        Object.defineProperty(Delay2.prototype, "numOfDelayedAttempts", {
+          get: function() {
+            return this.attempt;
+          },
+          enumerable: true,
+          configurable: true
+        });
+        return Delay2;
+      }()
+    );
+    exports.Delay = Delay;
+  }
+});
+
+// ../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/delay/skip-first/skip-first.delay.js
+var require_skip_first_delay = __commonJS({
+  "../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/delay/skip-first/skip-first.delay.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2)
+            if (b2.hasOwnProperty(p))
+              d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1)
+          throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f)
+          throw new TypeError("Generator is already executing.");
+        while (_)
+          try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+              return t;
+            if (y = 0, t)
+              op = [op[0] & 2, t.value];
+            switch (op[0]) {
+              case 0:
+              case 1:
+                t = op;
+                break;
+              case 4:
+                _.label++;
+                return { value: op[1], done: false };
+              case 5:
+                _.label++;
+                y = op[1];
+                op = [0];
+                continue;
+              case 7:
+                op = _.ops.pop();
+                _.trys.pop();
+                continue;
+              default:
+                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                  _ = 0;
+                  continue;
+                }
+                if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                  _.label = op[1];
+                  break;
+                }
+                if (op[0] === 6 && _.label < t[1]) {
+                  _.label = t[1];
+                  t = op;
+                  break;
+                }
+                if (t && _.label < t[2]) {
+                  _.label = t[2];
+                  _.ops.push(op);
+                  break;
+                }
+                if (t[2])
+                  _.ops.pop();
+                _.trys.pop();
+                continue;
+            }
+            op = body.call(thisArg, _);
+          } catch (e) {
+            op = [6, e];
+            y = 0;
+          } finally {
+            f = t = 0;
+          }
+        if (op[0] & 5)
+          throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var delay_base_1 = require_delay_base();
+    var SkipFirstDelay = (
+      /** @class */
+      function(_super) {
+        __extends(SkipFirstDelay2, _super);
+        function SkipFirstDelay2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        SkipFirstDelay2.prototype.apply = function() {
+          return __awaiter(this, void 0, void 0, function() {
+            return __generator(this, function(_a) {
+              return [2, this.isFirstAttempt ? true : _super.prototype.apply.call(this)];
+            });
+          });
+        };
+        Object.defineProperty(SkipFirstDelay2.prototype, "isFirstAttempt", {
+          get: function() {
+            return this.attempt === 0;
+          },
+          enumerable: true,
+          configurable: true
+        });
+        Object.defineProperty(SkipFirstDelay2.prototype, "numOfDelayedAttempts", {
+          get: function() {
+            return this.attempt - 1;
+          },
+          enumerable: true,
+          configurable: true
+        });
+        return SkipFirstDelay2;
+      }(delay_base_1.Delay)
+    );
+    exports.SkipFirstDelay = SkipFirstDelay;
+  }
+});
+
+// ../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/delay/always/always.delay.js
+var require_always_delay = __commonJS({
+  "../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/delay/always/always.delay.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2)
+            if (b2.hasOwnProperty(p))
+              d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var delay_base_1 = require_delay_base();
+    var AlwaysDelay = (
+      /** @class */
+      function(_super) {
+        __extends(AlwaysDelay2, _super);
+        function AlwaysDelay2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return AlwaysDelay2;
+      }(delay_base_1.Delay)
+    );
+    exports.AlwaysDelay = AlwaysDelay;
+  }
+});
+
+// ../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/delay/delay.factory.js
+var require_delay_factory = __commonJS({
+  "../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/delay/delay.factory.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var skip_first_delay_1 = require_skip_first_delay();
+    var always_delay_1 = require_always_delay();
+    function DelayFactory(options, attempt) {
+      var delay = initDelayClass(options);
+      delay.setAttemptNumber(attempt);
+      return delay;
+    }
+    exports.DelayFactory = DelayFactory;
+    function initDelayClass(options) {
+      if (!options.delayFirstAttempt) {
+        return new skip_first_delay_1.SkipFirstDelay(options);
+      }
+      return new always_delay_1.AlwaysDelay(options);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/backoff.js
+var require_backoff = __commonJS({
+  "../../node_modules/.pnpm/exponential-backoff@3.1.1/node_modules/exponential-backoff/dist/backoff.js"(exports) {
+    "use strict";
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1)
+          throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f)
+          throw new TypeError("Generator is already executing.");
+        while (_)
+          try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+              return t;
+            if (y = 0, t)
+              op = [op[0] & 2, t.value];
+            switch (op[0]) {
+              case 0:
+              case 1:
+                t = op;
+                break;
+              case 4:
+                _.label++;
+                return { value: op[1], done: false };
+              case 5:
+                _.label++;
+                y = op[1];
+                op = [0];
+                continue;
+              case 7:
+                op = _.ops.pop();
+                _.trys.pop();
+                continue;
+              default:
+                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                  _ = 0;
+                  continue;
+                }
+                if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                  _.label = op[1];
+                  break;
+                }
+                if (op[0] === 6 && _.label < t[1]) {
+                  _.label = t[1];
+                  t = op;
+                  break;
+                }
+                if (t && _.label < t[2]) {
+                  _.label = t[2];
+                  _.ops.push(op);
+                  break;
+                }
+                if (t[2])
+                  _.ops.pop();
+                _.trys.pop();
+                continue;
+            }
+            op = body.call(thisArg, _);
+          } catch (e) {
+            op = [6, e];
+            y = 0;
+          } finally {
+            f = t = 0;
+          }
+        if (op[0] & 5)
+          throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var options_1 = require_options();
+    var delay_factory_1 = require_delay_factory();
+    function backOff2(request, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      return __awaiter(this, void 0, void 0, function() {
+        var sanitizedOptions, backOff3;
+        return __generator(this, function(_a) {
+          switch (_a.label) {
+            case 0:
+              sanitizedOptions = options_1.getSanitizedOptions(options);
+              backOff3 = new BackOff(request, sanitizedOptions);
+              return [4, backOff3.execute()];
+            case 1:
+              return [2, _a.sent()];
+          }
+        });
+      });
+    }
+    exports.backOff = backOff2;
+    var BackOff = (
+      /** @class */
+      function() {
+        function BackOff2(request, options) {
+          this.request = request;
+          this.options = options;
+          this.attemptNumber = 0;
+        }
+        BackOff2.prototype.execute = function() {
+          return __awaiter(this, void 0, void 0, function() {
+            var e_1, shouldRetry;
+            return __generator(this, function(_a) {
+              switch (_a.label) {
+                case 0:
+                  if (!!this.attemptLimitReached)
+                    return [3, 7];
+                  _a.label = 1;
+                case 1:
+                  _a.trys.push([1, 4, , 6]);
+                  return [4, this.applyDelay()];
+                case 2:
+                  _a.sent();
+                  return [4, this.request()];
+                case 3:
+                  return [2, _a.sent()];
+                case 4:
+                  e_1 = _a.sent();
+                  this.attemptNumber++;
+                  return [4, this.options.retry(e_1, this.attemptNumber)];
+                case 5:
+                  shouldRetry = _a.sent();
+                  if (!shouldRetry || this.attemptLimitReached) {
+                    throw e_1;
+                  }
+                  return [3, 6];
+                case 6:
+                  return [3, 0];
+                case 7:
+                  throw new Error("Something went wrong.");
+              }
+            });
+          });
+        };
+        Object.defineProperty(BackOff2.prototype, "attemptLimitReached", {
+          get: function() {
+            return this.attemptNumber >= this.options.numOfAttempts;
+          },
+          enumerable: true,
+          configurable: true
+        });
+        BackOff2.prototype.applyDelay = function() {
+          return __awaiter(this, void 0, void 0, function() {
+            var delay;
+            return __generator(this, function(_a) {
+              switch (_a.label) {
+                case 0:
+                  delay = delay_factory_1.DelayFactory(this.options, this.attemptNumber);
+                  return [4, delay.apply()];
+                case 1:
+                  _a.sent();
+                  return [
+                    2
+                    /*return*/
+                  ];
+              }
+            });
+          });
+        };
+        return BackOff2;
+      }()
+    );
+  }
+});
+
+// src/client.ts
+var import_exponential_backoff = __toESM(require_backoff());
+
+// ../../node_modules/.pnpm/nanoevents@9.1.0/node_modules/nanoevents/index.js
+var createNanoEvents = () => ({
+  emit(event, ...args) {
+    for (let callbacks = this.events[event] || [], i = 0, length = callbacks.length; i < length; i++) {
+      callbacks[i](...args);
+    }
+  },
+  events: {},
+  on(event, cb) {
+    ;
+    (this.events[event] ||= []).push(cb);
+    return () => {
+      this.events[event] = this.events[event]?.filter((i) => cb !== i);
+    };
+  }
+});
+
+// src/bp-client.ts
+var getExtendedClient = (client) => {
+  if (typeof client.constructor !== "function" || typeof client.callAction !== "function" || !client.config || typeof client.config !== "object" || !client.config.headers) {
+    throw new Error("Client must be a valid instance of a Botpress client (@botpress/client)");
+  }
+  const botId = client.config.headers["x-bot-id"];
+  if (!botId?.length) {
+    throw new Error("Client must be instanciated with Bot ID");
+  }
+  const clone = () => {
+    const c = client;
+    if (c.clone && typeof c.clone === "function") {
+      return getExtendedClient(c.clone());
+    }
+    return getExtendedClient(new c.constructor(c.config));
+  };
+  return {
+    ...client,
+    botId,
+    axios: client.axiosInstance,
+    clone,
+    abortable: (signal) => {
+      const abortable = clone();
+      const instance = abortable.axios;
+      instance.defaults.signal = signal;
+      return abortable;
+    }
+  };
+};
+
+// src/errors.ts
+var getActionFromError = (error) => {
+  if (!isBotpressError(error)) {
+    return "retry";
+  }
+  if (error.type === "InvalidDataFormat") {
+    if (error.message?.includes("data/model/id")) {
+      return "fallback";
+    }
+    return "abort";
+  }
+  if (error.type === "Internal" || error.subtype === "UPSTREAM_PROVIDER_FAILED") {
+    return "fallback";
+  }
+  return "abort";
+};
+var isBotpressError = (error) => typeof error === "object" && error !== null && "isApiError" in error && "code" in error && "type" in error && "id" in error;
+
+// src/interceptors.ts
+var InterceptorManager = class {
+  _interceptors = [];
+  use(interceptor) {
+    this._interceptors.push(interceptor);
+    return () => this.remove(interceptor);
+  }
+  remove(interceptor) {
+    this._interceptors = this._interceptors.filter((i) => i !== interceptor);
+  }
+  async run(value, signal) {
+    let error = null;
+    let result = value;
+    let done = false;
+    for (const interceptor of this._interceptors) {
+      if (done) {
+        break;
+      }
+      if (signal.aborted) {
+        throw signal.reason;
+      }
+      await new Promise((resolve) => {
+        void interceptor(
+          error,
+          result,
+          (err, val) => {
+            error = err;
+            result = val;
+            resolve();
+          },
+          (err, val) => {
+            error = err;
+            result = val;
+            done = true;
+            resolve();
+          }
+        );
+      });
+    }
+    if (error) {
+      throw error;
+    }
+    return result;
+  }
+};
+
+// src/models.ts
+import { ResourceNotFoundError } from "@botpress/client";
+var PreferencesFile = "models.config.json";
+var VendorPreferences = ["google-ai", "anthropic", "openai"];
+var BestModelPreferences = ["4o", "3-5-sonnet", "gemini-1.5-pro"];
+var FastModelPreferences = ["gemini-1.5-flash", "4o-mini", "flash", "haiku"];
+var InputPricePenalty = 3;
+var OutputPricePenalty = 10;
+var LowTokensPenalty = 128e3;
+var isRecommended = (model) => model.tags.includes("recommended");
+var isDeprecated = (model) => model.tags.includes("deprecated");
+var isLowCost = (model) => model.tags.includes("low-cost");
+var hasVisionSupport = (model) => model.tags.includes("vision");
+var isGeneralPurpose = (model) => model.tags.includes("general-purpose");
+var scoreModel = (model, type, boosts = {}) => {
+  let score = 0;
+  const scores = [
+    ["input price penalty", model.input.costPer1MTokens > InputPricePenalty, -1],
+    ["output price penalty", model.output.costPer1MTokens > OutputPricePenalty, -1],
+    ["low tokens penalty", (model.input.maxTokens ?? 0 + model.output.maxTokens ?? 0) < LowTokensPenalty, -1],
+    ["recommended", isRecommended(model), 2],
+    ["deprecated", isDeprecated(model), -2],
+    ["vision support", hasVisionSupport(model), 1],
+    ["general purpose", isGeneralPurpose(model), 1],
+    ["vendor preference", VendorPreferences.includes(model.integration), 1],
+    ["best model preference", type === "best" && BestModelPreferences.some((x) => model.id.includes(x)), 1],
+    ["fast model preference penalty", type === "best" && FastModelPreferences.some((x) => model.id.includes(x)), -2],
+    ["fast model preference", type === "fast" && FastModelPreferences.some((x) => model.id.includes(x)), 2],
+    ["low cost", type === "fast" && isLowCost(model), 1]
+  ];
+  for (const rule in boosts) {
+    if (model.ref.includes(rule)) {
+      scores.push([`boost (${rule})`, true, Number(boosts[rule]) ?? 0]);
+    }
+  }
+  for (const [, condition, value] of scores) {
+    if (condition) {
+      score += value;
+    }
+  }
+  return score;
+};
+var getBestModels = (models, boosts = {}) => models.sort((a, b) => scoreModel(b, "best", boosts) - scoreModel(a, "best", boosts));
+var getFastModels = (models, boosts = {}) => models.sort((a, b) => scoreModel(b, "fast", boosts) - scoreModel(a, "fast", boosts));
+var pickModel = (models, downtimes = []) => {
+  const copy = [...models];
+  const elasped = (date) => new Date().getTime() - new Date(date).getTime();
+  const DOWNTIME_THRESHOLD = 1e3 * 60 * 5;
+  if (!copy.length) {
+    throw new Error("At least one model is required");
+  }
+  while (copy.length) {
+    const ref = copy.shift();
+    const downtime = downtimes.find((o) => o.ref === ref && elasped(o.startedAt) < DOWNTIME_THRESHOLD);
+    if (downtime) {
+      continue;
+    } else {
+      return ref;
+    }
+  }
+  throw new Error(`All models are down: ${models.join(", ")}`);
+};
+var ModelProvider = class {
+};
+var RemoteModelProvider = class extends ModelProvider {
+  _client;
+  constructor(client) {
+    super();
+    this._client = getExtendedClient(client);
+  }
+  async fetchInstalledModels() {
+    const { bot } = await this._client.getBot({ id: this._client.botId });
+    const models = [];
+    const registered = Object.values(bot.integrations).filter((x) => x.status === "registered");
+    await Promise.allSettled(
+      registered.map(async (integration) => {
+        const { output } = await this._client.callAction({
+          type: `${integration.name}:listLanguageModels`,
+          input: {}
+        });
+        if (!output?.models?.length) {
+          return;
+        }
+        for (const model of output.models) {
+          if (model.name && model.id && model.input && model.tags) {
+            models.push({
+              ref: `${integration.name}:${model.id}`,
+              integration: integration.name,
+              id: model.id,
+              name: model.name,
+              description: model.description,
+              input: model.input,
+              output: model.output,
+              tags: model.tags
+            });
+          }
+        }
+      })
+    );
+    return models;
+  }
+  async fetchModelPreferences() {
+    try {
+      const { file } = await this._client.getFile({ id: PreferencesFile });
+      const { data } = await this._client.axios.get(file.url, {
+        // we piggy-back axios to avoid adding a new dependency
+        // unset all headers to avoid S3 pre-signed signature mismatch
+        headers: Object.keys(this._client.config.headers).reduce(
+          (acc, key) => {
+            acc[key] = void 0;
+            return acc;
+          },
+          {}
+        )
+      });
+      return data;
+    } catch (err) {
+      if (err instanceof ResourceNotFoundError) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async saveModelPreferences(preferences) {
+    await this._client.uploadFile({
+      key: PreferencesFile,
+      content: JSON.stringify(preferences, null, 2),
+      index: false,
+      tags: {
+        system: "true",
+        purpose: "config"
+      }
+    });
+  }
+  async deleteModelPreferences() {
+    await this._client.deleteFile({ id: PreferencesFile }).catch(() => {
+    });
+  }
+};
+
+// src/client.ts
+var Cognitive = class {
+  interceptors = {
+    request: new InterceptorManager(),
+    response: new InterceptorManager()
+  };
+  _client;
+  _preferences = null;
+  _provider;
+  _events = createNanoEvents();
+  _downtimes = [];
+  constructor(props) {
+    this._client = getExtendedClient(props.client);
+    this._provider = props.provider ?? new RemoteModelProvider(props.client);
+  }
+  on(event, cb) {
+    return this._events.on(event, cb);
+  }
+  async fetchPreferences() {
+    if (this._preferences) {
+      return this._preferences;
+    }
+    this._preferences = await this._provider.fetchModelPreferences();
+    if (this._preferences) {
+      return this._preferences;
+    }
+    const models = await this._provider.fetchInstalledModels();
+    this._preferences = {
+      best: getBestModels(models).map((m) => m.ref),
+      fast: getFastModels(models).map((m) => m.ref),
+      downtimes: []
+    };
+    await this._provider.saveModelPreferences(this._preferences);
+    return this._preferences;
+  }
+  async setPreferences(preferences, save = false) {
+    this._preferences = preferences;
+    if (save) {
+      await this._provider.saveModelPreferences(preferences);
+    }
+  }
+  async _selectModel(ref) {
+    const parseRef = (ref2) => {
+      const parts = ref2.split(":");
+      return { integration: parts[0], model: parts.slice(1).join(":") };
+    };
+    const preferences = await this.fetchPreferences();
+    preferences.best ??= [];
+    preferences.fast ??= [];
+    preferences.downtimes ??= [];
+    const downtimes = [...preferences.downtimes, ...this._downtimes ?? []];
+    if (ref === "best") {
+      return parseRef(pickModel(preferences.best, downtimes));
+    }
+    if (ref === "fast") {
+      return parseRef(pickModel(preferences.fast, downtimes));
+    }
+    return parseRef(pickModel([ref, ...preferences.best, ...preferences.fast], downtimes));
+  }
+  async generateContent(input) {
+    const start = Date.now();
+    const signal = input.signal ?? AbortSignal.timeout(3e4);
+    const client = this._client.abortable(signal);
+    let props = { input };
+    let integration;
+    let model;
+    const { output, meta } = await (0, import_exponential_backoff.backOff)(
+      async () => {
+        const selection = await this._selectModel(input.model ?? "best");
+        integration = selection.integration;
+        model = selection.model;
+        props = await this.interceptors.request.run({ input }, signal);
+        return client.callAction({
+          type: `${integration}:generateContent`,
+          input: {
+            ...props.input,
+            model: { id: model }
+          }
+        });
+      },
+      {
+        retry: async (err, _attempt) => {
+          if (signal?.aborted) {
+            this._events.emit("aborted", props, err);
+            return false;
+          }
+          if (_attempt > 3) {
+            this._events.emit("error", props, err);
+            return false;
+          }
+          const action = getActionFromError(err);
+          if (action === "abort") {
+            this._events.emit("error", props, err);
+            return false;
+          }
+          if (action === "fallback") {
+            this._downtimes.push({
+              ref: `${integration}:${model}`,
+              startedAt: new Date().toISOString(),
+              reason: "Model is down"
+            });
+            await this._provider.saveModelPreferences({
+              ...this._preferences ?? { best: [], downtimes: [], fast: [] },
+              downtimes: [...this._preferences.downtimes ?? [], ...this._downtimes ?? []]
+            });
+            this._events.emit("fallback", props, err);
+            return true;
+          }
+          this._events.emit("retry", props, err);
+          return true;
+        }
+      }
+    );
+    const response = {
+      output,
+      meta: {
+        cached: meta.cached ?? false,
+        model: { integration, model },
+        latency: Date.now() - start,
+        cost: { input: output.usage.inputCost, output: output.usage.outputCost },
+        tokens: { input: output.usage.inputTokens, output: output.usage.outputTokens }
+      }
+    };
+    this._events.emit("response", props, response);
+    return this.interceptors.response.run(response, signal);
+  }
+};
+export {
+  Cognitive,
+  ModelProvider,
+  RemoteModelProvider
+};
+//# sourceMappingURL=index.mjs.map