@jaypie/testkit 1.1.33 → 1.1.35

package/dist/mock/index.js

@@ -350,7 +350,7 @@ beforeAll(async () => {
 const cloneDeep = createMockWrappedFunction(original$1.cloneDeep, {
     throws: true,
 });
-const envBoolean = createMockReturnedFunction(true);
+const envBoolean$1 = createMockReturnedFunction(true);
 const envsKey = createMockWrappedFunction(original$1.envsKey, `_MOCK_ENVS_KEY_[${TAG$2}]`);
 const errorFromStatusCode = createMockFunction((statusCode, message = `Mock error for status code ${statusCode}`) => {
     try {
@@ -462,7 +462,7 @@ const jaypieHandler = createMockFunction((handler, options = {}) => {
 });
 const sleep = createMockResolvedFunction(true);
 const uuid = createMockWrappedFunction(original$1.uuid, `00000000-0000-0000-0000-000000000000`);
-const ERROR = original$1.ERROR;
+const ERROR$1 = original$1.ERROR;
 const HTTP$1 = original$1.HTTP;
 const JAYPIE = original$1.JAYPIE;
 const PROJECT = original$1.PROJECT;
@@ -473,7 +473,7 @@ var core = /*#__PURE__*/Object.freeze({
     BadGatewayError: BadGatewayError,
     BadRequestError: BadRequestError,
     ConfigurationError: ConfigurationError,
-    ERROR: ERROR,
+    ERROR: ERROR$1,
     ForbiddenError: ForbiddenError,
     GatewayTimeoutError: GatewayTimeoutError,
     GoneError: GoneError,
@@ -496,7 +496,7 @@ var core = /*#__PURE__*/Object.freeze({
     UnreachableCodeError: UnreachableCodeError,
     VALIDATE: VALIDATE,
     cloneDeep: cloneDeep,
-    envBoolean: envBoolean,
+    envBoolean: envBoolean$1,
     envsKey: envsKey,
     errorFromStatusCode: errorFromStatusCode,
     force: force,
@@ -580,7 +580,6 @@ const expressHandler = createMockFunction((handlerOrProps, propsOrHandler) => {
         if (!props.setup)
             props.setup = [];
         props.setup = force.array(props.setup);
-        // @ts-expect-error TODO: cannot resolve; fix when JaypieHandler moves to TypeScript
         props.setup.unshift((req) => {
             if (!req || typeof req !== "object") {
                 throw new BadRequestError$1("req must be an object");
@@ -635,9 +634,9 @@ const expressHandler = createMockFunction((handlerOrProps, propsOrHandler) => {
             // In the mock context, if status is a function we are in a "supertest"
             if (supertestMode && typeof res.status === "function") {
                 // In theory jaypieFunction has handled all errors
-                const errorStatus = error.status || HTTP.CODE.INTERNAL_ERROR;
+                const errorStatus = error?.status || HTTP.CODE.INTERNAL_ERROR;
                 let errorResponse;
-                if (typeof error.json === "function") {
+                if (typeof error?.json === "function") {
                     errorResponse = error.json();
                 }
                 else {
@@ -703,6 +702,15 @@ var express = /*#__PURE__*/Object.freeze({
     notImplementedRoute: notImplementedRoute
 });
 
+const isProductionEnv = createMockReturnedFunction(false);
+const isNodeTestEnv = createMockReturnedFunction(true);
+
+var kit = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isNodeTestEnv: isNodeTestEnv,
+    isProductionEnv: isProductionEnv
+});
+
 // Mock implementation of lambdaHandler that follows the original implementation pattern
 const lambdaHandler = createMockFunction((handler, props = {}) => {
     // If handler is an object and options is a function, swap them
@@ -798,6 +806,12 @@ const Toolkit = createMockWrappedObject(original$4.Toolkit, {
 const JaypieToolkit = createMockWrappedObject(original$4.JaypieToolkit, {
     isClass: true,
 });
+const LlmMessageRole = createMockWrappedObject(original$4.LlmMessageRole, {
+    isClass: true,
+});
+const LlmMessageType = createMockWrappedObject(original$4.LlmMessageType, {
+    isClass: true,
+});
 // Tool collections
 const toolkit = new original$4.JaypieToolkit([
     random,
@@ -812,11 +826,630 @@ var llm = /*#__PURE__*/Object.freeze({
     JaypieToolkit: JaypieToolkit,
     LLM: LLM,
     Llm: Llm,
+    LlmMessageRole: LlmMessageRole,
+    LlmMessageType: LlmMessageType,
     Toolkit: Toolkit,
     toolkit: toolkit,
     tools: tools
 });
 
+const DEFAULT = {
+    LEVEL: "debug",
+    VAR_LEVEL: "debug",
+};
+const ERROR_PREFIX = "[logger]";
+const ERROR = {
+    VAR: {
+        EMPTY_OBJECT: `${ERROR_PREFIX} Logger.var() called with empty object`,
+        MULTIPLE_KEYS: `${ERROR_PREFIX} Logger.var() called with multiple keys`,
+        NULL_OBJECT: `${ERROR_PREFIX} Logger.var() called with null`,
+        UNDEFINED_MESSAGE: `${ERROR_PREFIX} Logger.var() called with \`undefined\` message`,
+    },
+};
+const FORMAT = {
+    JSON: "json",
+    TEXT: "text",
+};
+const LEVEL = {
+    ALL: "all",
+    DEBUG: "debug",
+    ERROR: "error",
+    FATAL: "fatal",
+    INFO: "info",
+    SILENT: "silent",
+    TRACE: "trace",
+    WARN: "warn",
+};
+const LEVEL_VALUES = {
+    all: 100,
+    debug: 70,
+    error: 10,
+    fatal: 1,
+    info: 50,
+    none: 0,
+    silent: 0,
+    trace: 90,
+    warn: 30,
+};
+
+function forceString(value, defaultValue = "") {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return String(defaultValue);
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
+function formatAsJsonString(subject) {
+    const SPACES = 0;
+    const UNUSED_PARAM = null;
+    switch (typeof subject) {
+        case "string":
+            if (subject === "")
+                return `""`;
+            try {
+                return JSON.stringify(JSON.parse(subject), UNUSED_PARAM, SPACES);
+            }
+            catch {
+                return subject;
+            }
+        case "object":
+            try {
+                if (subject &&
+                    subject instanceof Object &&
+                    !Array.isArray(subject) &&
+                    subject.constructor &&
+                    subject.constructor !== Object &&
+                    "toString" in subject &&
+                    typeof subject.toString === "function") {
+                    return subject.toString();
+                }
+                return JSON.stringify(subject, UNUSED_PARAM, SPACES);
+            }
+            catch (error) {
+                if (error instanceof TypeError) {
+                    const truncatedSubject = Object.keys(subject).reduce((newSubject, key) => {
+                        const nextSubject = { ...newSubject };
+                        nextSubject[key] = String(subject[key]);
+                        return nextSubject;
+                    }, {});
+                    return formatAsJsonString(truncatedSubject);
+                }
+                throw error;
+            }
+        default:
+            return String(subject);
+    }
+}
+function stringify(...params) {
+    if (params.length === 0)
+        return "";
+    if (params.length === 1) {
+        return formatAsJsonString(params[0]);
+    }
+    const noObjects = params.reduce((previous, current) => {
+        if (typeof current === "object" && current !== null) {
+            return false;
+        }
+        return previous;
+    }, true);
+    if (noObjects) {
+        const formatted = params.map(formatAsJsonString);
+        return formatted.join(" ");
+    }
+    return formatAsJsonString(params);
+}
+function out(line, { level = "debug" } = {}) {
+    let lineStr;
+    if (typeof line !== "string") {
+        lineStr = stringify(line);
+    }
+    else {
+        lineStr = line;
+    }
+    let outputFunction;
+    switch (level) {
+        case LEVEL.INFO:
+            outputFunction = console.info;
+            break;
+        case LEVEL.WARN:
+            outputFunction = console.warn;
+            break;
+        case LEVEL.ERROR:
+        case LEVEL.FATAL:
+            outputFunction = console.error;
+            break;
+        case LEVEL.TRACE:
+        case LEVEL.DEBUG:
+            outputFunction = console.debug;
+            break;
+        default:
+            outputFunction = console.log;
+            break;
+    }
+    try {
+        outputFunction(lineStr);
+    }
+    catch (error) {
+        console.warn(error);
+        console.log(lineStr);
+    }
+}
+function parse(message) {
+    if (typeof message !== "string") {
+        return message;
+    }
+    try {
+        return JSON.parse(message);
+    }
+    catch {
+        return message;
+    }
+}
+function parsesTo(message) {
+    if (typeof message !== "string") {
+        return {
+            parses: false,
+            message,
+        };
+    }
+    try {
+        return {
+            parses: true,
+            message: JSON.parse(message),
+        };
+    }
+    catch {
+        return {
+            parses: false,
+            message,
+        };
+    }
+}
+
+class Logger {
+    constructor({ format = process.env.LOG_FORMAT || DEFAULT.LEVEL, level = process.env.LOG_LEVEL || DEFAULT.LEVEL, tags = {}, varLevel = process.env.LOG_VAR_LEVEL || DEFAULT.VAR_LEVEL, } = {}) {
+        this.options = {
+            format,
+            level,
+            varLevel,
+        };
+        this.tags = {};
+        Object.keys(tags).forEach((key) => {
+            this.tags[key] = forceString(tags[key]);
+        });
+        this.debug = this.createLogMethod(LEVEL.DEBUG, format, level);
+        this.error = this.createLogMethod(LEVEL.ERROR, format, level);
+        this.fatal = this.createLogMethod(LEVEL.FATAL, format, level);
+        this.info = this.createLogMethod(LEVEL.INFO, format, level);
+        this.trace = this.createLogMethod(LEVEL.TRACE, format, level);
+        this.warn = this.createLogMethod(LEVEL.WARN, format, level);
+        const varLevelMethod = this[varLevel];
+        this.var = varLevelMethod?.var || this.debug.var;
+    }
+    createLogMethod(logLevel, format, checkLevel) {
+        const logFn = (...messages) => {
+            if (LEVEL_VALUES[logLevel] <= LEVEL_VALUES[checkLevel]) {
+                if (format === FORMAT.JSON) {
+                    const message = stringify(...messages);
+                    const parses = parsesTo(message);
+                    const json = {
+                        log: logLevel,
+                        message,
+                        ...this.tags,
+                    };
+                    if (parses.parses) {
+                        json.data = parses.message;
+                    }
+                    out(json, { level: logLevel });
+                }
+                else {
+                    const message = stringify(...messages);
+                    out(message, { level: logLevel });
+                }
+            }
+        };
+        logFn.var = (messageObject, messageValue) => {
+            if (messageObject === undefined) {
+                this.warn(ERROR.VAR.UNDEFINED_MESSAGE);
+            }
+            let msgObj;
+            if (typeof messageObject !== "object" || messageObject === null) {
+                if (typeof messageObject !== "object") {
+                    if (messageValue === undefined)
+                        messageValue = "undefined";
+                    msgObj = { [String(messageObject)]: messageValue };
+                }
+                else {
+                    this.warn(ERROR.VAR.NULL_OBJECT);
+                    return logFn(messageObject);
+                }
+            }
+            else {
+                msgObj = messageObject;
+            }
+            const keys = Object.keys(msgObj);
+            if (keys.length === 0) {
+                this.warn(ERROR.VAR.EMPTY_OBJECT);
+                return logFn(msgObj);
+            }
+            if (keys.length > 1) {
+                this.warn(ERROR.VAR.MULTIPLE_KEYS);
+                return logFn(msgObj);
+            }
+            if (format === FORMAT.JSON) {
+                const messageKey = keys[0];
+                const messageVal = msgObj[messageKey];
+                const json = {
+                    data: parse(messageVal),
+                    dataType: typeof messageVal,
+                    log: logLevel,
+                    message: stringify(messageVal),
+                    var: messageKey,
+                    ...this.tags,
+                };
+                if (LEVEL_VALUES[logLevel] <= LEVEL_VALUES[checkLevel]) {
+                    out(json, { level: logLevel });
+                }
+            }
+            else {
+                return logFn(msgObj);
+            }
+        };
+        return logFn;
+    }
+    tag(key, value) {
+        if (value) {
+            this.tags[forceString(key)] = forceString(value);
+            return;
+        }
+        if (Array.isArray(key)) {
+            key.forEach((k) => {
+                this.tags[forceString(k)] = "";
+            });
+            return;
+        }
+        if (key === null) {
+            this.tags.null = "";
+            return;
+        }
+        if (typeof key === "object") {
+            Object.keys(key).forEach((k) => {
+                this.tags[forceString(k)] = forceString(key[k]);
+            });
+        }
+        else {
+            this.tags[forceString(key)] = "";
+        }
+    }
+    untag(key) {
+        if (Array.isArray(key)) {
+            key.forEach((k) => {
+                delete this.tags[forceString(k)];
+            });
+            return;
+        }
+        if (key === null) {
+            delete this.tags.null;
+            return;
+        }
+        if (typeof key === "object") {
+            Object.keys(key).forEach((k) => {
+                delete this.tags[forceString(k)];
+            });
+        }
+        else {
+            delete this.tags[forceString(key)];
+        }
+    }
+    with(key, value) {
+        const logger = new Logger(this.options);
+        logger.tag(this.tags);
+        logger.tag(key, value);
+        return logger;
+    }
+}
+
+function logTags(withTags) {
+    const { PROJECT_COMMIT, PROJECT_ENV, PROJECT_KEY, PROJECT_SERVICE, PROJECT_SPONSOR, PROJECT_VERSION, } = process.env;
+    const tags = {};
+    if (PROJECT_COMMIT) {
+        tags.commit = PROJECT_COMMIT;
+    }
+    if (PROJECT_ENV) {
+        tags.env = PROJECT_ENV;
+    }
+    if (PROJECT_KEY) {
+        tags.project = PROJECT_KEY;
+    }
+    if (PROJECT_SERVICE) {
+        tags.service = PROJECT_SERVICE;
+    }
+    if (PROJECT_SPONSOR) {
+        tags.sponsor = PROJECT_SPONSOR;
+    }
+    if (process.env.npm_package_version || PROJECT_VERSION) {
+        tags.version = (process.env.npm_package_version ||
+            PROJECT_VERSION);
+    }
+    return {
+        ...tags,
+        ...withTags,
+    };
+}
+
+function forceVar(key, value) {
+    if (typeof key === "undefined") {
+        return {};
+    }
+    if (typeof key === "object" && key !== null) {
+        if (Object.keys(key).length === 1) {
+            return key;
+        }
+        else {
+            return { value: key };
+        }
+    }
+    const keyStr = forceString(key);
+    if (typeof value === "undefined") {
+        return { [keyStr]: "" };
+    }
+    else {
+        return { [keyStr]: value };
+    }
+}
+
+function isAxiosResponse(response) {
+    if (typeof response !== "object" || response === null) {
+        return false;
+    }
+    const r = response;
+    return !!(r &&
+        r.config &&
+        r.data &&
+        r.headers &&
+        r.request &&
+        r.status &&
+        r.statusText);
+}
+function filterAxiosResponse(response) {
+    if (!isAxiosResponse(response)) {
+        return response;
+    }
+    const r = response;
+    const newResponse = {
+        data: r.data,
+        headers: r.headers,
+        status: r.status,
+        statusText: r.statusText,
+    };
+    if (r.isAxiosError) {
+        newResponse.isAxiosError = r.isAxiosError;
+    }
+    return newResponse;
+}
+const axiosResponseVarPipeline = {
+    filter: filterAxiosResponse,
+    key: "response",
+};
+function isError(item) {
+    if (typeof item !== "object" || item === null) {
+        return false;
+    }
+    if (item instanceof Error) {
+        return true;
+    }
+    const i = item;
+    if (i.isProjectError) {
+        return true;
+    }
+    return false;
+}
+function filterErrorVar(item) {
+    if (!isError(item)) {
+        return item;
+    }
+    const e = item;
+    const newItem = {
+        message: e.message,
+        name: e.name,
+    };
+    if (e.cause) {
+        newItem.cause = e.cause;
+    }
+    if (e.stack) {
+        newItem.stack = e.stack;
+    }
+    if (e.isProjectError) {
+        newItem.isProjectError = e.isProjectError;
+        newItem.title = e.title;
+        newItem.detail = e.detail;
+        newItem.status = e.status;
+    }
+    return newItem;
+}
+const errorVarPipeline = {
+    filter: filterErrorVar,
+    key: "error",
+};
+const pipelines = [axiosResponseVarPipeline, errorVarPipeline];
+
+function keyValueToArray(keyValue) {
+    const key = Object.keys(keyValue)[0];
+    return [key, keyValue[key]];
+}
+function logVar(key, value) {
+    let [k, v] = keyValueToArray(forceVar(key, value));
+    for (const pipeline of pipelines) {
+        if (k === pipeline.key) {
+            v = pipeline.filter(v);
+        }
+    }
+    return { [k]: v };
+}
+
+function envBoolean(key, { defaultValue }) {
+    const value = process.env[key];
+    if (value === undefined)
+        return defaultValue;
+    const lower = value.toLowerCase();
+    return !(lower === "" ||
+        lower === "0" ||
+        lower === "f" ||
+        lower === "false" ||
+        lower === "n" ||
+        lower === "no");
+}
+class JaypieLogger {
+    constructor({ level = process.env.LOG_LEVEL, tags = {}, } = {}) {
+        this._params = { level, tags };
+        this._loggers = [];
+        this._tags = {};
+        this._withLoggers = {};
+        this.level = level || DEFAULT.LEVEL;
+        this._tags = { ...logTags(), ...tags };
+        this._logger = new Logger({
+            format: FORMAT.JSON,
+            level: this.level,
+            tags: this._tags,
+        });
+        this._loggers = [this._logger];
+        this.debug = ((...args) => this._logger.debug(...args));
+        this.debug.var = (messageObject, messageValue) => this._logger.debug.var(messageObject, messageValue);
+        this.error = ((...args) => this._logger.error(...args));
+        this.error.var = (messageObject, messageValue) => this._logger.error.var(messageObject, messageValue);
+        this.fatal = ((...args) => this._logger.fatal(...args));
+        this.fatal.var = (messageObject, messageValue) => this._logger.fatal.var(messageObject, messageValue);
+        this.info = ((...args) => this._logger.info(...args));
+        this.info.var = (messageObject, messageValue) => this._logger.info.var(messageObject, messageValue);
+        this.trace = ((...args) => this._logger.trace(...args));
+        this.trace.var = (messageObject, messageValue) => this._logger.trace.var(messageObject, messageValue);
+        this.warn = ((...args) => this._logger.warn(...args));
+        this.warn.var = (messageObject, messageValue) => this._logger.warn.var(messageObject, messageValue);
+        this.var = (messageObject, messageValue) => this._logger.var(logVar(messageObject, messageValue));
+    }
+    init() {
+        for (const logger of this._loggers) {
+            if ("init" in logger && typeof logger.init === "function") {
+                logger.init();
+            }
+        }
+        const level = this._params.level;
+        const tags = this._params.tags;
+        this.level = level || DEFAULT.LEVEL;
+        this._tags = { ...logTags(), ...tags };
+        this._logger = new Logger({
+            format: FORMAT.JSON,
+            level: this.level,
+            tags: this._tags,
+        });
+        this._loggers = [this._logger];
+        this._withLoggers = {};
+        const levels = [
+            "debug",
+            "error",
+            "fatal",
+            "info",
+            "trace",
+            "warn",
+        ];
+        levels.forEach((lvl) => {
+            this[lvl] = ((...args) => {
+                this._logger[lvl](...args);
+            });
+            this[lvl].var = (messageObject, messageValue) => {
+                this._logger[lvl].var(messageObject, messageValue);
+            };
+        });
+    }
+    lib({ level, lib, tags = {}, } = {}) {
+        const newTags = Object.assign({}, this._tags, tags);
+        if (lib) {
+            newTags.lib = lib;
+        }
+        const logger = new JaypieLogger({
+            level: (() => {
+                if (level) {
+                    return level;
+                }
+                if (process.env.MODULE_LOG_LEVEL) {
+                    return process.env.MODULE_LOG_LEVEL;
+                }
+                if (envBoolean("MODULE_LOGGER", { defaultValue: false })) {
+                    return process.env.LOG_LEVEL;
+                }
+                return LEVEL.SILENT;
+            })(),
+            tags: newTags,
+        });
+        this._loggers.push(logger._logger);
+        return logger;
+    }
+    tag(tags) {
+        for (const logger of this._loggers) {
+            logger.tag(tags);
+        }
+        Object.assign(this._tags, tags);
+    }
+    untag(key) {
+        for (const logger of this._loggers) {
+            logger.untag(key);
+        }
+        if (Array.isArray(key)) {
+            key.forEach((k) => {
+                delete this._tags[String(k)];
+            });
+        }
+        else if (typeof key === "object" && key !== null) {
+            Object.keys(key).forEach((k) => {
+                delete this._tags[k];
+            });
+        }
+        else {
+            delete this._tags[String(key)];
+        }
+    }
+    with(key, value) {
+        if (!key || (typeof key !== "object" && value === undefined)) {
+            throw new Error("ConfigurationError: with() requires an object argument or key-value pair");
+        }
+        const loggerKey = JSON.stringify([key, value]);
+        if (Object.keys(this._withLoggers).includes(loggerKey)) {
+            return this._withLoggers[loggerKey];
+        }
+        const logger = new JaypieLogger({
+            level: this.level,
+            tags: { ...this._tags },
+        });
+        logger._logger = this._logger.with(key, value);
+        logger._loggers = [logger._logger];
+        this._withLoggers[loggerKey] = logger;
+        this._loggers.push(logger._logger);
+        return logger;
+    }
+}
+function createLogger$1(tags = {}) {
+    const jaypieLogger = new JaypieLogger({
+        tags,
+    });
+    return jaypieLogger;
+}
+
+createLogger$1();
+
+const mockLog = mockLogFactory();
+const createLogger = createMockWrappedFunction(createLogger$1, mockLog);
+
+var logger = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    FORMAT: FORMAT,
+    LEVEL: LEVEL,
+    Logger: Logger,
+    createLogger: createLogger,
+    default: mockLog
+});
+
 // Mongoose mock functions
 const connect = createMockReturnedFunction(true);
 const connectFromSecretEnv = createMockReturnedFunction(true);
@@ -870,7 +1503,7 @@ var textract$1 = /*#__PURE__*/Object.freeze({
 
 // Import all mocks
 // Export default object with all mocks
-var index = {
+const mock = {
     // AWS module
     ...aws,
     // Core module
@@ -879,15 +1512,17 @@ var index = {
     ...datadog,
     // Express module
     ...express,
+    ...kit,
     // Lambda module
     ...lambda,
     // LLM module
     ...llm,
+    ...logger,
     // Mongoose module (now empty)
     ...mongoose,
     // Textract module
     ...textract$1,
 };
 
-export { BadGatewayError, BadRequestError, ConfigurationError, DATADOG, ERROR, EXPRESS, ForbiddenError, GatewayTimeoutError, GoneError, HTTP$1 as HTTP, IllogicalError, InternalError, JAYPIE, JaypieToolkit, LLM, Llm, MarkdownPage, MethodNotAllowedError, MultiError, NotFoundError, NotImplementedError, PROJECT, ProjectError, ProjectMultiError, RejectedError, TeapotError, Toolkit, UnauthorizedError, UnavailableError, UnhandledError, UnreachableCodeError, VALIDATE, badRequestRoute, cloneDeep, connect, connectFromSecretEnv, cors, index as default, disconnect, echoRoute, envBoolean, envsKey, errorFromStatusCode, expressHandler, expressHttpCodeHandler, forbiddenRoute, force, formatError, getEnvSecret, getHeaderFrom, getMessages, getObjectKeyCaseInsensitive, getSecret, getSingletonMessage, getTextractJob, goneRoute, hasDatadogEnv, isClass, isJaypieError, jaypieHandler, lambdaHandler, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute, optional, placeholders, required, resolveValue, safeParseFloat, sendBatchMessages, sendMessage, sendTextractJob, sleep, submitDistribution, submitMetric, submitMetricSet, textractJsonToMarkdown, toolkit, tools, uuid, validate };
+export { BadGatewayError, BadRequestError, ConfigurationError, DATADOG, ERROR$1 as ERROR, EXPRESS, FORMAT, ForbiddenError, GatewayTimeoutError, GoneError, HTTP$1 as HTTP, IllogicalError, InternalError, JAYPIE, JaypieToolkit, LEVEL, LLM, Llm, LlmMessageRole, LlmMessageType, Logger, MarkdownPage, MethodNotAllowedError, MultiError, NotFoundError, NotImplementedError, PROJECT, ProjectError, ProjectMultiError, RejectedError, TeapotError, Toolkit, UnauthorizedError, UnavailableError, UnhandledError, UnreachableCodeError, VALIDATE, badRequestRoute, cloneDeep, connect, connectFromSecretEnv, cors, createLogger, mock as default, disconnect, echoRoute, envBoolean$1 as envBoolean, envsKey, errorFromStatusCode, expressHandler, expressHttpCodeHandler, forbiddenRoute, force, formatError, getEnvSecret, getHeaderFrom, getMessages, getObjectKeyCaseInsensitive, getSecret, getSingletonMessage, getTextractJob, goneRoute, hasDatadogEnv, isClass, isJaypieError, isNodeTestEnv, isProductionEnv, jaypieHandler, lambdaHandler, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute, optional, placeholders, required, resolveValue, safeParseFloat, sendBatchMessages, sendMessage, sendTextractJob, sleep, submitDistribution, submitMetric, submitMetricSet, textractJsonToMarkdown, toolkit, tools, uuid, validate };
 //# sourceMappingURL=index.js.map