@hestia-earth/api 0.27.4 → 0.27.6

package/errors.d.ts

@@ -0,0 +1,40 @@
+import { Express, Request, Response, NextFunction } from 'express';
+import { NextHandleFunction } from 'connect';
+export declare enum Errors {
+    UnderMaintenance = "under-maintenance",
+    ReadOnly = "read-only",
+    InvalidQueryParam = "invalid-param-query",
+    MissingQueryParam = "missing-param-query",
+    InvalidBodyParam = "invalid-param-body",
+    MissingBodyParam = "missing-param-body",
+    MissingHeaderParam = "missing-param-header",
+    SchemaInvalid = "invalid-schema",
+    NotFound = "not-found",
+    Unauthorized = "Unauthorized",
+    BadRequest = "bad-request",
+    FilesLocked = "files-locked"
+}
+export declare enum StatusCodes {
+    BadRequest = 400,
+    Unauthorized = 401,
+    Forbidden = 403,
+    NotFound = 404,
+    MethodNotAllowed = 405,
+    Conflict = 409,
+    RateLimit = 429,
+    ServiceUnavailable = 503,
+    InternalServerError = 500
+}
+export declare class HestiaError extends Error {
+    details: {};
+    statusCode?: StatusCodes;
+    constructor(message: string, details?: {}, statusCode?: StatusCodes);
+}
+export declare const throwError: (message: string, details?: any, statusCode?: StatusCodes) => never;
+export declare const isRecalculationError: (e: any) => boolean;
+export declare const shouldHandleError: (error: Error) => boolean;
+export declare const errorMessage: (error?: Error) => string;
+export declare const errorHandler: (err: any, _r: Request, res: Response, _n?: NextFunction) => Response<any, Record<string, any>>;
+export declare const handleSyntaxError: (middleware: NextHandleFunction) => (req: Request, res: Response, next: NextFunction) => void;
+declare const _default: (app: Express) => void;
+export default _default;

package/errors.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSyntaxError = exports.errorHandler = exports.errorMessage = exports.shouldHandleError = exports.isRecalculationError = exports.throwError = exports.HestiaError = exports.StatusCodes = exports.Errors = void 0;
+const Sentry = require("@sentry/node");
+const pick = require('lodash.pick');
+const logger_1 = require("./logger");
+var Errors;
+(function (Errors) {
+    Errors["UnderMaintenance"] = "under-maintenance";
+    Errors["ReadOnly"] = "read-only";
+    Errors["InvalidQueryParam"] = "invalid-param-query";
+    Errors["MissingQueryParam"] = "missing-param-query";
+    Errors["InvalidBodyParam"] = "invalid-param-body";
+    Errors["MissingBodyParam"] = "missing-param-body";
+    Errors["MissingHeaderParam"] = "missing-param-header";
+    Errors["SchemaInvalid"] = "invalid-schema";
+    Errors["NotFound"] = "not-found";
+    Errors["Unauthorized"] = "Unauthorized";
+    Errors["BadRequest"] = "bad-request";
+    Errors["FilesLocked"] = "files-locked";
+})(Errors || (exports.Errors = Errors = {}));
+var StatusCodes;
+(function (StatusCodes) {
+    StatusCodes[StatusCodes["BadRequest"] = 400] = "BadRequest";
+    StatusCodes[StatusCodes["Unauthorized"] = 401] = "Unauthorized";
+    StatusCodes[StatusCodes["Forbidden"] = 403] = "Forbidden";
+    StatusCodes[StatusCodes["NotFound"] = 404] = "NotFound";
+    StatusCodes[StatusCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+    StatusCodes[StatusCodes["Conflict"] = 409] = "Conflict";
+    StatusCodes[StatusCodes["RateLimit"] = 429] = "RateLimit";
+    StatusCodes[StatusCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    StatusCodes[StatusCodes["InternalServerError"] = 500] = "InternalServerError";
+})(StatusCodes || (exports.StatusCodes = StatusCodes = {}));
+class HestiaError extends Error {
+    details;
+    statusCode;
+    constructor(message, details = {}, statusCode) {
+        super(message);
+        this.details = details;
+        this.statusCode = statusCode;
+        this.name = 'HestiaError';
+    }
+}
+exports.HestiaError = HestiaError;
+const throwError = (message, details, statusCode) => {
+    throw new HestiaError(message, details, statusCode);
+};
+exports.throwError = throwError;
+const isHestiaError = (error) => error.name === 'HestiaError';
+const isRecalculationError = e => ['recalculation-error', 'invalid-nodes'].includes(e.message);
+exports.isRecalculationError = isRecalculationError;
+const shouldHandleError = (error) => !isHestiaError(error);
+exports.shouldHandleError = shouldHandleError;
+const statusCode = (error) => error.statusCode ||
+    ((0, exports.errorMessage)(error).includes(Errors.NotFound)
+        ? StatusCodes.NotFound
+        : error.message === Errors.Unauthorized
+            ? StatusCodes.Unauthorized
+            : isHestiaError(error)
+                ? StatusCodes.BadRequest
+                : StatusCodes.InternalServerError);
+const errorMessage = (error) => error?.message || 'There was an error processing your request.';
+exports.errorMessage = errorMessage;
+const errorHandler = (err, _r, res, _n) => {
+    const unexpectedError = (0, exports.shouldHandleError)(err);
+    unexpectedError && logger_1.logger.error(err.stack ? err.stack : err);
+    const message = (0, exports.errorMessage)(err);
+    res.statusCode = statusCode(err);
+    return res.json({
+        message,
+        ...pick(err, ['details', 'oauthError'])
+    });
+};
+exports.errorHandler = errorHandler;
+const handleSyntaxError = (middleware) => (req, res, next) => middleware(req, res, err => {
+    if (err instanceof SyntaxError) {
+        const message = (0, exports.errorMessage)(err);
+        res.statusCode = 400;
+        return res.json({ message });
+    }
+    next();
+});
+exports.handleSyntaxError = handleSyntaxError;
+exports.default = (app) => {
+    app.use(Sentry.Handlers.errorHandler({ shouldHandleError: exports.shouldHandleError }));
+    app.use(exports.errorHandler);
+};

package/esm/errors.js

@@ -0,0 +1,77 @@
+import * as Sentry from '@sentry/node';
+const pick = require('lodash.pick');
+import { logger } from './logger.js';
+export var Errors;
+(function (Errors) {
+    Errors["UnderMaintenance"] = "under-maintenance";
+    Errors["ReadOnly"] = "read-only";
+    Errors["InvalidQueryParam"] = "invalid-param-query";
+    Errors["MissingQueryParam"] = "missing-param-query";
+    Errors["InvalidBodyParam"] = "invalid-param-body";
+    Errors["MissingBodyParam"] = "missing-param-body";
+    Errors["MissingHeaderParam"] = "missing-param-header";
+    Errors["SchemaInvalid"] = "invalid-schema";
+    Errors["NotFound"] = "not-found";
+    Errors["Unauthorized"] = "Unauthorized";
+    Errors["BadRequest"] = "bad-request";
+    Errors["FilesLocked"] = "files-locked";
+})(Errors || (Errors = {}));
+export var StatusCodes;
+(function (StatusCodes) {
+    StatusCodes[StatusCodes["BadRequest"] = 400] = "BadRequest";
+    StatusCodes[StatusCodes["Unauthorized"] = 401] = "Unauthorized";
+    StatusCodes[StatusCodes["Forbidden"] = 403] = "Forbidden";
+    StatusCodes[StatusCodes["NotFound"] = 404] = "NotFound";
+    StatusCodes[StatusCodes["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+    StatusCodes[StatusCodes["Conflict"] = 409] = "Conflict";
+    StatusCodes[StatusCodes["RateLimit"] = 429] = "RateLimit";
+    StatusCodes[StatusCodes["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+    StatusCodes[StatusCodes["InternalServerError"] = 500] = "InternalServerError";
+})(StatusCodes || (StatusCodes = {}));
+export class HestiaError extends Error {
+    details;
+    statusCode;
+    constructor(message, details = {}, statusCode) {
+        super(message);
+        this.details = details;
+        this.statusCode = statusCode;
+        this.name = 'HestiaError';
+    }
+}
+export const throwError = (message, details, statusCode) => {
+    throw new HestiaError(message, details, statusCode);
+};
+const isHestiaError = (error) => error.name === 'HestiaError';
+export const isRecalculationError = e => ['recalculation-error', 'invalid-nodes'].includes(e.message);
+export const shouldHandleError = (error) => !isHestiaError(error);
+const statusCode = (error) => error.statusCode ||
+    (errorMessage(error).includes(Errors.NotFound)
+        ? StatusCodes.NotFound
+        : error.message === Errors.Unauthorized
+            ? StatusCodes.Unauthorized
+            : isHestiaError(error)
+                ? StatusCodes.BadRequest
+                : StatusCodes.InternalServerError);
+export const errorMessage = (error) => error?.message || 'There was an error processing your request.';
+export const errorHandler = (err, _r, res, _n) => {
+    const unexpectedError = shouldHandleError(err);
+    unexpectedError && logger.error(err.stack ? err.stack : err);
+    const message = errorMessage(err);
+    res.statusCode = statusCode(err);
+    return res.json({
+        message,
+        ...pick(err, ['details', 'oauthError'])
+    });
+};
+export const handleSyntaxError = (middleware) => (req, res, next) => middleware(req, res, err => {
+    if (err instanceof SyntaxError) {
+        const message = errorMessage(err);
+        res.statusCode = 400;
+        return res.json({ message });
+    }
+    next();
+});
+export default (app) => {
+    app.use(Sentry.Handlers.errorHandler({ shouldHandleError }));
+    app.use(errorHandler);
+};

package/esm/files/model/llm-preset.js

@@ -0,0 +1,61 @@
+import { throwError } from '../../errors.js';
+export var LlmEngine;
+(function (LlmEngine) {
+    LlmEngine["claude"] = "claude";
+    LlmEngine["gemini"] = "gemini";
+    LlmEngine["openrouter"] = "openrouter";
+    LlmEngine["zai"] = "zai";
+    LlmEngine["hf"] = "hf";
+    LlmEngine["nvidia"] = "nvidia";
+    LlmEngine["deepseek"] = "deepseek";
+    LlmEngine["openai"] = "openai";
+})(LlmEngine || (LlmEngine = {}));
+export var LlmApiKey;
+(function (LlmApiKey) {
+    LlmApiKey["OPENROUTER_KEY"] = "OPENROUTER_KEY";
+    LlmApiKey["Z_AI_KEY"] = "Z_AI_KEY";
+    LlmApiKey["HF_TOKEN"] = "HF_TOKEN";
+    LlmApiKey["NVIDIA_API_KEY"] = "NVIDIA_API_KEY";
+    LlmApiKey["DEEP_SEEK_API_KEY"] = "DEEP_SEEK_API_KEY";
+    LlmApiKey["ANTHROPIC_API_KEY"] = "ANTHROPIC_API_KEY";
+    LlmApiKey["OPENAI_API_KEY"] = "OPENAI_API_KEY";
+})(LlmApiKey || (LlmApiKey = {}));
+export const llmApiKeys = Object.values(LlmApiKey);
+export const stripPresetSecrets = (presets = []) => presets.map(({ config, ...preset }) => {
+    const { apiKeys, ...rest } = config || {};
+    return { ...preset, config: rest };
+});
+const engines = Object.values(LlmEngine);
+const isEngine = (value) => engines.includes(value);
+const isReviewer = (value) => typeof value === 'string' && value.length > 0 && isEngine(value.split(':')[0]);
+const isStringRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const invalid = (reason) => throwError('invalid-llm-presets', { reason });
+const validateEngine = (field, value) => (value === undefined || isEngine(value)) || invalid(`invalid ${field} "${value}"`);
+const validateOptionalString = (field, value) => (value === undefined || typeof value === 'string') || invalid(`${field} must be a string`);
+const validateOptionalBoolean = (field, value) => (value === undefined || typeof value === 'boolean') || invalid(`${field} must be a boolean`);
+const validateReviewers = (reviewers) => (reviewers === undefined || (Array.isArray(reviewers) && reviewers.every(isReviewer))) ||
+    invalid('reviewers must be a list of "engine" or "engine:model"');
+const validateApiKeys = (apiKeys) => (apiKeys === undefined ||
+    (isStringRecord(apiKeys) &&
+        Object.entries(apiKeys).every(([key, value]) => llmApiKeys.includes(key) && typeof value === 'string'))) || invalid('apiKeys contains an unknown key or non-string value');
+const validateConfig = (config) => {
+    isStringRecord(config) || invalid('config must be an object');
+    validateEngine('engine', config.engine);
+    validateEngine('fixEngine', config.fixEngine);
+    validateOptionalString('model', config.model);
+    validateOptionalString('fixModel', config.fixModel);
+    validateReviewers(config.reviewers);
+    validateApiKeys(config.apiKeys);
+};
+const validatePreset = (preset) => {
+    (isStringRecord(preset) && typeof preset.name === 'string' && preset.name.length > 0) ||
+        invalid('each preset requires a non-empty name');
+    validateOptionalString('description', preset.description);
+    validateOptionalBoolean('default', preset.default);
+    validateConfig(preset.config);
+};
+export const validateLlmPresets = (value) => {
+    Array.isArray(value) || invalid('presets must be a list');
+    value.forEach(validatePreset);
+    return value;
+};

package/esm/logger.js

@@ -0,0 +1,31 @@
+import { createLogger, format, transports } from 'winston';
+const { combine, timestamp, json } = format;
+const logFilename = process.env.LOG_FILENAME;
+const handleExceptions = process.env.NODE_ENV !== 'test';
+const options = {
+    file: {
+        level: (process.env.LOG_LEVEL || 'info').toLowerCase(),
+        filename: logFilename,
+        handleExceptions,
+        json: true,
+        maxsize: 5242880,
+        maxFiles: 5,
+        colorize: false
+    },
+    console: {
+        level: 'debug',
+        handleExceptions,
+        json: false,
+        colorize: true
+    }
+};
+export const logger = createLogger({
+    format: combine(timestamp(), json()),
+    transports: [...(logFilename ? [new transports.File(options.file)] : []), new transports.Console(options.console)],
+    exitOnError: false
+});
+export const stream = {
+    write: message => {
+        logger.info(message);
+    }
+};

package/esm/models.js

@@ -4,6 +4,7 @@ export * from './analyses/model/model.js';
 export * from './cycles/model/model.js';
 export * from './drafts/model/model.js';
 export * from './earth-engine/model/model.js';
+export * from './files/model/llm-preset.js';
 export * from './files/model/model.js';
 export * from './glossary/model/model.js';
 export * from './migrations/model/model.js';

package/esm/settings/model/model.js

@@ -10,6 +10,7 @@ export var SettingKey;
     SettingKey["calculationEngine"] = "calculationEngine";
     SettingKey["users"] = "users";
     SettingKey["dataReleases"] = "dataReleases";
+    SettingKey["llmPresets"] = "llmPresets";
 })(SettingKey || (SettingKey = {}));
 export class Setting extends BaseModel {
     key;

package/files/model/llm-preset.d.ts

@@ -0,0 +1,37 @@
+export declare enum LlmEngine {
+    claude = "claude",
+    gemini = "gemini",
+    openrouter = "openrouter",
+    zai = "zai",
+    hf = "hf",
+    nvidia = "nvidia",
+    deepseek = "deepseek",
+    openai = "openai"
+}
+export declare enum LlmApiKey {
+    OPENROUTER_KEY = "OPENROUTER_KEY",
+    Z_AI_KEY = "Z_AI_KEY",
+    HF_TOKEN = "HF_TOKEN",
+    NVIDIA_API_KEY = "NVIDIA_API_KEY",
+    DEEP_SEEK_API_KEY = "DEEP_SEEK_API_KEY",
+    ANTHROPIC_API_KEY = "ANTHROPIC_API_KEY",
+    OPENAI_API_KEY = "OPENAI_API_KEY"
+}
+export declare const llmApiKeys: LlmApiKey[];
+export type LlmReviewer = LlmEngine | `${LlmEngine}:${string}`;
+export interface LlmPresetConfig {
+    engine?: LlmEngine;
+    model?: string;
+    reviewers?: LlmReviewer[];
+    fixEngine?: LlmEngine;
+    fixModel?: string;
+    apiKeys?: Partial<Record<LlmApiKey, string>>;
+}
+export interface LlmPreset {
+    name: string;
+    description?: string;
+    default?: boolean;
+    config: LlmPresetConfig;
+}
+export declare const stripPresetSecrets: (presets?: LlmPreset[]) => LlmPreset[];
+export declare const validateLlmPresets: (value: any) => LlmPreset[];

package/files/model/llm-preset.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLlmPresets = exports.stripPresetSecrets = exports.llmApiKeys = exports.LlmApiKey = exports.LlmEngine = void 0;
+const errors_1 = require("../../errors");
+var LlmEngine;
+(function (LlmEngine) {
+    LlmEngine["claude"] = "claude";
+    LlmEngine["gemini"] = "gemini";
+    LlmEngine["openrouter"] = "openrouter";
+    LlmEngine["zai"] = "zai";
+    LlmEngine["hf"] = "hf";
+    LlmEngine["nvidia"] = "nvidia";
+    LlmEngine["deepseek"] = "deepseek";
+    LlmEngine["openai"] = "openai";
+})(LlmEngine || (exports.LlmEngine = LlmEngine = {}));
+var LlmApiKey;
+(function (LlmApiKey) {
+    LlmApiKey["OPENROUTER_KEY"] = "OPENROUTER_KEY";
+    LlmApiKey["Z_AI_KEY"] = "Z_AI_KEY";
+    LlmApiKey["HF_TOKEN"] = "HF_TOKEN";
+    LlmApiKey["NVIDIA_API_KEY"] = "NVIDIA_API_KEY";
+    LlmApiKey["DEEP_SEEK_API_KEY"] = "DEEP_SEEK_API_KEY";
+    LlmApiKey["ANTHROPIC_API_KEY"] = "ANTHROPIC_API_KEY";
+    LlmApiKey["OPENAI_API_KEY"] = "OPENAI_API_KEY";
+})(LlmApiKey || (exports.LlmApiKey = LlmApiKey = {}));
+exports.llmApiKeys = Object.values(LlmApiKey);
+const stripPresetSecrets = (presets = []) => presets.map(({ config, ...preset }) => {
+    const { apiKeys, ...rest } = config || {};
+    return { ...preset, config: rest };
+});
+exports.stripPresetSecrets = stripPresetSecrets;
+const engines = Object.values(LlmEngine);
+const isEngine = (value) => engines.includes(value);
+const isReviewer = (value) => typeof value === 'string' && value.length > 0 && isEngine(value.split(':')[0]);
+const isStringRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const invalid = (reason) => (0, errors_1.throwError)('invalid-llm-presets', { reason });
+const validateEngine = (field, value) => (value === undefined || isEngine(value)) || invalid(`invalid ${field} "${value}"`);
+const validateOptionalString = (field, value) => (value === undefined || typeof value === 'string') || invalid(`${field} must be a string`);
+const validateOptionalBoolean = (field, value) => (value === undefined || typeof value === 'boolean') || invalid(`${field} must be a boolean`);
+const validateReviewers = (reviewers) => (reviewers === undefined || (Array.isArray(reviewers) && reviewers.every(isReviewer))) ||
+    invalid('reviewers must be a list of "engine" or "engine:model"');
+const validateApiKeys = (apiKeys) => (apiKeys === undefined ||
+    (isStringRecord(apiKeys) &&
+        Object.entries(apiKeys).every(([key, value]) => exports.llmApiKeys.includes(key) && typeof value === 'string'))) || invalid('apiKeys contains an unknown key or non-string value');
+const validateConfig = (config) => {
+    isStringRecord(config) || invalid('config must be an object');
+    validateEngine('engine', config.engine);
+    validateEngine('fixEngine', config.fixEngine);
+    validateOptionalString('model', config.model);
+    validateOptionalString('fixModel', config.fixModel);
+    validateReviewers(config.reviewers);
+    validateApiKeys(config.apiKeys);
+};
+const validatePreset = (preset) => {
+    (isStringRecord(preset) && typeof preset.name === 'string' && preset.name.length > 0) ||
+        invalid('each preset requires a non-empty name');
+    validateOptionalString('description', preset.description);
+    validateOptionalBoolean('default', preset.default);
+    validateConfig(preset.config);
+};
+const validateLlmPresets = (value) => {
+    Array.isArray(value) || invalid('presets must be a list');
+    value.forEach(validatePreset);
+    return value;
+};
+exports.validateLlmPresets = validateLlmPresets;

package/logger.d.ts

@@ -0,0 +1,4 @@
+export declare const logger: import("winston").Logger;
+export declare const stream: {
+    write: (message: any) => void;
+};

package/logger.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stream = exports.logger = void 0;
+const winston_1 = require("winston");
+const { combine, timestamp, json } = winston_1.format;
+const logFilename = process.env.LOG_FILENAME;
+const handleExceptions = process.env.NODE_ENV !== 'test';
+const options = {
+    file: {
+        level: (process.env.LOG_LEVEL || 'info').toLowerCase(),
+        filename: logFilename,
+        handleExceptions,
+        json: true,
+        maxsize: 5242880,
+        maxFiles: 5,
+        colorize: false
+    },
+    console: {
+        level: 'debug',
+        handleExceptions,
+        json: false,
+        colorize: true
+    }
+};
+exports.logger = (0, winston_1.createLogger)({
+    format: combine(timestamp(), json()),
+    transports: [...(logFilename ? [new winston_1.transports.File(options.file)] : []), new winston_1.transports.Console(options.console)],
+    exitOnError: false
+});
+exports.stream = {
+    write: message => {
+        exports.logger.info(message);
+    }
+};

package/models.d.ts

@@ -4,6 +4,7 @@ export * from './analyses/model/model';
 export * from './cycles/model/model';
 export * from './drafts/model/model';
 export * from './earth-engine/model/model';
+export * from './files/model/llm-preset';
 export * from './files/model/model';
 export * from './glossary/model/model';
 export * from './migrations/model/model';

package/models.js

@@ -20,6 +20,7 @@ __exportStar(require("./analyses/model/model"), exports);
 __exportStar(require("./cycles/model/model"), exports);
 __exportStar(require("./drafts/model/model"), exports);
 __exportStar(require("./earth-engine/model/model"), exports);
+__exportStar(require("./files/model/llm-preset"), exports);
 __exportStar(require("./files/model/model"), exports);
 __exportStar(require("./glossary/model/model"), exports);
 __exportStar(require("./migrations/model/model"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hestia-earth/api",
-  "version": "0.27.4",
+  "version": "0.27.6",
   "description": "Hestia API definitions",
   "main": "models.js",
   "module": "esm/models.js",

package/reconciliations/model/validations.d.ts

@@ -9,4 +9,4 @@ export declare const validateExpectedNodes: (nodes: Node[]) => string[];
 export declare const validateImpactAssessmentLinks: (nodes: Node[]) => string[];
 export declare const validatePrivate: (cycle: ICycleJSONLD) => string[];
 export declare const validateProductCorrespondence: (expectedProducts: (ITermJSONLD | Term)[], recalculatedProducts: (ITermJSONLD | Term)[], idRecalculated: string) => string[];
-export declare const getMainErrorMessage: (errors: any) => "expected-not-private" | "recalculation-error" | "invalid-nodes";
+export declare const getMainErrorMessage: (errors: any) => "recalculation-error" | "invalid-nodes" | "expected-not-private";

package/settings/model/model.d.ts

@@ -8,7 +8,8 @@ export declare enum SettingKey {
     aggregationEngine = "aggregationEngine",
     calculationEngine = "calculationEngine",
     users = "users",
-    dataReleases = "dataReleases"
+    dataReleases = "dataReleases",
+    llmPresets = "llmPresets"
 }
 export interface IReleaseData {
     name?: string;

package/settings/model/model.js

@@ -13,6 +13,7 @@ var SettingKey;
     SettingKey["calculationEngine"] = "calculationEngine";
     SettingKey["users"] = "users";
     SettingKey["dataReleases"] = "dataReleases";
+    SettingKey["llmPresets"] = "llmPresets";
 })(SettingKey || (exports.SettingKey = SettingKey = {}));
 class Setting extends model_base_1.BaseModel {
     key;