@jaypie/testkit 1.1.36 → 1.2.0-rc.0

package/dist/mock/index.js

@@ -1,18 +1,20 @@
 import * as original from '@jaypie/aws';
 import { vi, beforeAll } from 'vitest';
-import * as original$1 from '@jaypie/core';
-import { log, BadRequestError as BadRequestError$1, UnhandledError as UnhandledError$1 } from '@jaypie/core';
-export { log } from '@jaypie/core';
-import * as original$2 from '@jaypie/datadog';
-import * as original$3 from '@jaypie/express';
-import * as original$4 from '@jaypie/llm';
+import { log, createLogger as createLogger$1, FORMAT, LEVEL, Logger } from '@jaypie/logger';
+export { FORMAT, LEVEL, Logger, log } from '@jaypie/logger';
+import * as errors from '@jaypie/errors';
+import { BadRequestError as BadRequestError$1, UnhandledError as UnhandledError$1 } from '@jaypie/errors';
+import * as kit$1 from '@jaypie/kit';
+import * as original$1 from '@jaypie/datadog';
+import * as original$2 from '@jaypie/express';
+import * as original$3 from '@jaypie/llm';
 import { mongoose as mongoose$1 } from '@jaypie/mongoose';
 export { mongoose } from '@jaypie/mongoose';
 import { readFile } from 'fs/promises';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { TextractDocument } from 'amazon-textract-response-parser';
-import * as original$5 from '@jaypie/textract';
+import * as original$4 from '@jaypie/textract';
 
 /**
  * Internal wrapper for vi.fn() that adds _jaypie: true to all mocks
@@ -308,7 +310,8 @@ function spyLog(logInstance) {
                 originalMethods[method] =
                     logInstance[method];
                 // Use type assertion after checking existence
-                logInstance[method] = mockLog[method];
+                logInstance[method] =
+                    mockLog[method];
             }
         });
         originalLogMethods.set(logInstance, originalMethods);
@@ -318,40 +321,40 @@ function spyLog(logInstance) {
 /* eslint-disable @typescript-eslint/no-unsafe-function-type */
 // Constants for mock values
 const TAG$2 = "CORE";
-const BadGatewayError = createMockError(original$1.BadGatewayError);
-const BadRequestError = createMockError(original$1.BadRequestError);
-const ConfigurationError = createMockError(original$1.ConfigurationError);
-const ForbiddenError = createMockError(original$1.ForbiddenError);
-const GatewayTimeoutError = createMockError(original$1.GatewayTimeoutError);
-const GoneError = createMockError(original$1.GoneError);
-const IllogicalError = createMockError(original$1.IllogicalError);
-const InternalError = createMockError(original$1.InternalError);
-const MethodNotAllowedError = createMockError(original$1.MethodNotAllowedError);
-const MultiError = createMockError(original$1.MultiError);
-const NotFoundError = createMockError(original$1.NotFoundError);
-const NotImplementedError = createMockError(original$1.NotImplementedError);
-const ProjectError = createMockError(original$1.ProjectError);
-const ProjectMultiError = createMockError(original$1.ProjectMultiError);
-const RejectedError = createMockError(original$1.RejectedError);
-const TeapotError = createMockError(original$1.TeapotError);
-const UnauthorizedError = createMockError(original$1.UnauthorizedError);
-const UnavailableError = createMockError(original$1.UnavailableError);
-const UnhandledError = createMockError(original$1.UnhandledError);
-const UnreachableCodeError = createMockError(original$1.UnreachableCodeError);
-// Mock core functions
-const validate = createMockWrappedObject(original$1.validate, {
-    fallback: false,
-    throws: true,
-});
+// JaypieError is the base class - export it directly from errors
+const JaypieError = errors.JaypieError;
+const BadGatewayError = createMockError(errors.BadGatewayError);
+const BadRequestError = createMockError(errors.BadRequestError);
+const ConfigurationError = createMockError(errors.ConfigurationError);
+const CorsError = createMockError(errors.CorsError);
+const ForbiddenError = createMockError(errors.ForbiddenError);
+const GatewayTimeoutError = createMockError(errors.GatewayTimeoutError);
+const GoneError = createMockError(errors.GoneError);
+const IllogicalError = createMockError(errors.IllogicalError);
+const InternalError = createMockError(errors.InternalError);
+const MethodNotAllowedError = createMockError(errors.MethodNotAllowedError);
+// Backwards compatibility aliases
+const MultiError = createMockError(errors.InternalError);
+const NotFoundError = createMockError(errors.NotFoundError);
+const NotImplementedError = createMockError(errors.NotImplementedError);
+const ProjectError = createMockError(errors.InternalError);
+const ProjectMultiError = createMockError(errors.InternalError);
+const RejectedError = createMockError(errors.RejectedError);
+const TeapotError = createMockError(errors.TeapotError);
+const TooManyRequestsError = createMockError(errors.TooManyRequestsError);
+const UnauthorizedError = createMockError(errors.UnauthorizedError);
+const UnavailableError = createMockError(errors.UnavailableError);
+const UnhandledError = createMockError(errors.UnhandledError);
+const UnreachableCodeError = createMockError(errors.UnreachableCodeError);
 beforeAll(async () => {
     spyLog(log);
 });
 // Add missing core functions
-const cloneDeep = createMockWrappedFunction(original$1.cloneDeep, {
+const cloneDeep = createMockWrappedFunction(kit$1.cloneDeep, {
     throws: true,
 });
-const envBoolean$1 = createMockReturnedFunction(true);
-const envsKey = createMockWrappedFunction(original$1.envsKey, `_MOCK_ENVS_KEY_[${TAG$2}]`);
+const envBoolean = createMockReturnedFunction(true);
+const envsKey = createMockWrappedFunction(kit$1.envsKey, `_MOCK_ENVS_KEY_[${TAG$2}]`);
 const errorFromStatusCode = createMockFunction((statusCode, message = `Mock error for status code ${statusCode}`) => {
     try {
         // Try to mimic original implementation
@@ -388,36 +391,29 @@ const errorFromStatusCode = createMockFunction((statusCode, message = `Mock erro
         return new Error(`_MOCK_ERROR_FROM_STATUS_CODE_[${TAG$2}][${statusCode}]`);
     }
 });
-const formatError = createMockWrappedFunction(original$1.formatError, `_MOCK_FORMAT_ERROR_[${TAG$2}]`);
-const getHeaderFrom = createMockWrappedFunction(original$1.getHeaderFrom, `_MOCK_GET_HEADER_FROM_[${TAG$2}]`);
-const getObjectKeyCaseInsensitive = createMockWrappedFunction(original$1.getObjectKeyCaseInsensitive, `_MOCK_GET_OBJECT_KEY_CASE_INSENSITIVE_[${TAG$2}]`);
-const isClass = createMockWrappedFunction(original$1.isClass, `_MOCK_IS_CLASS_[${TAG$2}]`);
-const isJaypieError = createMockWrappedFunction(original$1.isJaypieError, false);
-// Optional/Required validation functions
-const optional = createMockWrappedObject(original$1.optional, {
-    fallback: true,
-    throws: true,
-});
-const required = createMockWrappedObject(original$1.required, {
-    fallback: true,
-    throws: true,
-});
-const resolveValue = createMockWrappedFunction(original$1.resolveValue, `_MOCK_RESOLVE_VALUE_[${TAG$2}]`);
-const safeParseFloat = createMockWrappedFunction(original$1.safeParseFloat, `_MOCK_SAFE_PARSE_FLOAT_[${TAG$2}]`);
-const placeholders = createMockWrappedFunction(original$1.placeholders, `_MOCK_PLACEHOLDERS_[${TAG$2}]`);
+const formatError = createMockWrappedFunction(kit$1.formatError, `_MOCK_FORMAT_ERROR_[${TAG$2}]`);
+// Alias for errorFromStatusCode (exported from @jaypie/errors as jaypieErrorFromStatus)
+const jaypieErrorFromStatus = errorFromStatusCode;
+const getHeaderFrom = createMockWrappedFunction(kit$1.getHeaderFrom, `_MOCK_GET_HEADER_FROM_[${TAG$2}]`);
+const getObjectKeyCaseInsensitive = createMockWrappedFunction(kit$1.getObjectKeyCaseInsensitive, `_MOCK_GET_OBJECT_KEY_CASE_INSENSITIVE_[${TAG$2}]`);
+const isClass = createMockWrappedFunction(kit$1.isClass, `_MOCK_IS_CLASS_[${TAG$2}]`);
+const isJaypieError = createMockWrappedFunction(errors.isJaypieError, false);
+const resolveValue = createMockWrappedFunction(kit$1.resolveValue, `_MOCK_RESOLVE_VALUE_[${TAG$2}]`);
+const safeParseFloat = createMockWrappedFunction(kit$1.safeParseFloat, `_MOCK_SAFE_PARSE_FLOAT_[${TAG$2}]`);
+const placeholders = createMockWrappedFunction(kit$1.placeholders, `_MOCK_PLACEHOLDERS_[${TAG$2}]`);
 // Add force utilities to help with jaypieHandler implementation
-const force = createMockWrappedObject(original$1.force);
+const force = createMockWrappedObject(kit$1.force);
 const jaypieHandler = createMockFunction((handler, options = {}) => {
     return async (...args) => {
         let result;
         let thrownError;
         // Destructure options with defaults
-        const { setup = [], teardown = [], unavailable = original$1.force.boolean(process.env.PROJECT_UNAVAILABLE), validate = [], } = options;
+        const { setup = [], teardown = [], unavailable = kit$1.force.boolean(process.env.PROJECT_UNAVAILABLE), validate = [], } = options;
         // Check if service is unavailable
         if (unavailable)
             throw new UnavailableError("Service unavailable");
         // Run validation functions
-        const validateFunctions = original$1.force.array(validate);
+        const validateFunctions = kit$1.force.array(validate);
         for (const validator of validateFunctions) {
             if (typeof validator === "function") {
                 const valid = await validator(...args);
@@ -428,7 +424,7 @@ const jaypieHandler = createMockFunction((handler, options = {}) => {
         }
         try {
             // Run setup functions
-            const setupFunctions = original$1.force.array(setup);
+            const setupFunctions = kit$1.force.array(setup);
             for (const setupFunction of setupFunctions) {
                 if (typeof setupFunction === "function") {
                     await setupFunction(...args);
@@ -441,7 +437,7 @@ const jaypieHandler = createMockFunction((handler, options = {}) => {
             thrownError = error;
         }
         // Run teardown functions (always run even if there was an error)
-        const teardownFunctions = original$1.force.array(teardown);
+        const teardownFunctions = kit$1.force.array(teardown);
         for (const teardownFunction of teardownFunctions) {
             if (typeof teardownFunction === "function") {
                 try {
@@ -461,19 +457,17 @@ const jaypieHandler = createMockFunction((handler, options = {}) => {
     };
 });
 const sleep = createMockResolvedFunction(true);
-const uuid = createMockWrappedFunction(original$1.uuid, `00000000-0000-0000-0000-000000000000`);
-const ERROR$1 = original$1.ERROR;
-const HTTP$1 = original$1.HTTP;
-const JAYPIE = original$1.JAYPIE;
-const PROJECT = original$1.PROJECT;
-const VALIDATE = original$1.VALIDATE;
+const uuid = createMockWrappedFunction(() => "00000000-0000-0000-0000-000000000000", `00000000-0000-0000-0000-000000000000`);
+const HTTP$1 = kit$1.HTTP;
+const JAYPIE = kit$1.JAYPIE;
+const PROJECT = kit$1.PROJECT;
 
 var core = /*#__PURE__*/Object.freeze({
     __proto__: null,
     BadGatewayError: BadGatewayError,
     BadRequestError: BadRequestError,
     ConfigurationError: ConfigurationError,
-    ERROR: ERROR$1,
+    CorsError: CorsError,
     ForbiddenError: ForbiddenError,
     GatewayTimeoutError: GatewayTimeoutError,
     GoneError: GoneError,
@@ -481,6 +475,7 @@ var core = /*#__PURE__*/Object.freeze({
     IllogicalError: IllogicalError,
     InternalError: InternalError,
     JAYPIE: JAYPIE,
+    JaypieError: JaypieError,
     MethodNotAllowedError: MethodNotAllowedError,
     MultiError: MultiError,
     NotFoundError: NotFoundError,
@@ -490,13 +485,13 @@ var core = /*#__PURE__*/Object.freeze({
     ProjectMultiError: ProjectMultiError,
     RejectedError: RejectedError,
     TeapotError: TeapotError,
+    TooManyRequestsError: TooManyRequestsError,
     UnauthorizedError: UnauthorizedError,
     UnavailableError: UnavailableError,
     UnhandledError: UnhandledError,
     UnreachableCodeError: UnreachableCodeError,
-    VALIDATE: VALIDATE,
     cloneDeep: cloneDeep,
-    envBoolean: envBoolean$1,
+    envBoolean: envBoolean,
     envsKey: envsKey,
     errorFromStatusCode: errorFromStatusCode,
     force: force,
@@ -505,20 +500,18 @@ var core = /*#__PURE__*/Object.freeze({
     getObjectKeyCaseInsensitive: getObjectKeyCaseInsensitive,
     isClass: isClass,
     isJaypieError: isJaypieError,
+    jaypieErrorFromStatus: jaypieErrorFromStatus,
     jaypieHandler: jaypieHandler,
     log: log,
-    optional: optional,
     placeholders: placeholders,
-    required: required,
     resolveValue: resolveValue,
     safeParseFloat: safeParseFloat,
     sleep: sleep,
-    uuid: uuid,
-    validate: validate
+    uuid: uuid
 });
 
-const DATADOG = original$2.DATADOG;
-const hasDatadogEnv = createMockWrappedFunction(original$2.hasDatadogEnv, false);
+const DATADOG = original$1.DATADOG;
+const hasDatadogEnv = createMockWrappedFunction(original$1.hasDatadogEnv, false);
 const submitDistribution = createMockResolvedFunction(true);
 const submitMetric = createMockResolvedFunction(true);
 const submitMetricSet = createMockResolvedFunction(true);
@@ -538,25 +531,25 @@ const TAG$1 = "EXPRESS";
 const HTTP = {
     CODE: { OK: 200, CREATED: 201, NO_CONTENT: 204, INTERNAL_ERROR: 500 },
 };
-const EXPRESS = original$3.EXPRESS;
+const EXPRESS = original$2.EXPRESS;
 // Add Express route functions
-const badRequestRoute = createMockWrappedFunction(original$3.badRequestRoute, { error: `_MOCK_BAD_REQUEST_ROUTE_[${TAG$1}]` });
-const echoRoute = createMockWrappedFunction(original$3.echoRoute, (req) => req);
-const forbiddenRoute = createMockWrappedFunction(original$3.forbiddenRoute, { error: `_MOCK_FORBIDDEN_ROUTE_[${TAG$1}]` });
-const goneRoute = createMockWrappedFunction(original$3.goneRoute, {
+const badRequestRoute = createMockWrappedFunction(original$2.badRequestRoute, { error: `_MOCK_BAD_REQUEST_ROUTE_[${TAG$1}]` });
+const echoRoute = createMockWrappedFunction(original$2.echoRoute, (req) => req);
+const forbiddenRoute = createMockWrappedFunction(original$2.forbiddenRoute, { error: `_MOCK_FORBIDDEN_ROUTE_[${TAG$1}]` });
+const goneRoute = createMockWrappedFunction(original$2.goneRoute, {
     error: `_MOCK_GONE_ROUTE_[${TAG$1}]`,
 });
-const methodNotAllowedRoute = createMockWrappedFunction(original$3.methodNotAllowedRoute, { error: `_MOCK_METHOD_NOT_ALLOWED_ROUTE_[${TAG$1}]` });
-const noContentRoute = createMockWrappedFunction(original$3.noContentRoute, { status: 204 });
-const notFoundRoute = createMockWrappedFunction(original$3.notFoundRoute, {
+const methodNotAllowedRoute = createMockWrappedFunction(original$2.methodNotAllowedRoute, { error: `_MOCK_METHOD_NOT_ALLOWED_ROUTE_[${TAG$1}]` });
+const noContentRoute = createMockWrappedFunction(original$2.noContentRoute, { status: 204 });
+const notFoundRoute = createMockWrappedFunction(original$2.notFoundRoute, {
     error: `_MOCK_NOT_FOUND_ROUTE_[${TAG$1}]`,
 });
-const notImplementedRoute = createMockWrappedFunction(original$3.notImplementedRoute, { error: `_MOCK_NOT_IMPLEMENTED_ROUTE_[${TAG$1}]` });
-const expressHttpCodeHandler = createMockWrappedFunction(original$3.expressHttpCodeHandler, (...args) => {
+const notImplementedRoute = createMockWrappedFunction(original$2.notImplementedRoute, { error: `_MOCK_NOT_IMPLEMENTED_ROUTE_[${TAG$1}]` });
+const expressHttpCodeHandler = createMockWrappedFunction(original$2.expressHttpCodeHandler, (...args) => {
     const [req, res, next] = args;
     return res.status(200).send();
 });
-const cors = createMockWrappedFunction(original$3.cors);
+const cors = createMockWrappedFunction(original$2.cors);
 const expressHandler = createMockFunction((handlerOrProps, propsOrHandler) => {
     let handler;
     let props;
@@ -729,7 +722,7 @@ var lambda = /*#__PURE__*/Object.freeze({
     lambdaHandler: lambdaHandler
 });
 
-const LLM = original$4.LLM;
+const LLM = original$3.LLM;
 const mockOperate = createMockResolvedFunction({
     history: [
         {
@@ -800,27 +793,27 @@ const weather = createMockTool("weather", createMockResolvedFunction({
     location: `_MOCK_WEATHER_LOCATION`,
     forecast: [{ conditions: "good" }],
 }));
-const Toolkit = createMockWrappedObject(original$4.Toolkit, {
+const Toolkit = createMockWrappedObject(original$3.Toolkit, {
     isClass: true,
 });
-const JaypieToolkit = createMockWrappedObject(original$4.JaypieToolkit, {
+const JaypieToolkit = createMockWrappedObject(original$3.JaypieToolkit, {
     isClass: true,
 });
-const LlmMessageRole = createMockWrappedObject(original$4.LlmMessageRole, {
+const LlmMessageRole = createMockWrappedObject(original$3.LlmMessageRole, {
     isClass: true,
 });
-const LlmMessageType = createMockWrappedObject(original$4.LlmMessageType, {
+const LlmMessageType = createMockWrappedObject(original$3.LlmMessageType, {
     isClass: true,
 });
 // Provider mocks
-const GeminiProvider = createMockWrappedObject(original$4.GeminiProvider, {
+const GeminiProvider = createMockWrappedObject(original$3.GeminiProvider, {
     isClass: true,
 });
-const OpenRouterProvider = createMockWrappedObject(original$4.OpenRouterProvider, {
+const OpenRouterProvider = createMockWrappedObject(original$3.OpenRouterProvider, {
     isClass: true,
 });
 // Tool collections
-const toolkit = new original$4.JaypieToolkit([
+const toolkit = new original$3.JaypieToolkit([
     random,
     roll,
     time,
@@ -842,602 +835,6 @@ var llm = /*#__PURE__*/Object.freeze({
     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 formatted = params.map(formatAsJsonString);
-    return formatted.join(" ");
-}
-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);
 
@@ -1465,9 +862,9 @@ var mongoose = /*#__PURE__*/Object.freeze({
 
 // Constants for mock values
 const TAG = "TEXTRACT";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const MOCK_TEXTRACT_DOCUMENT_PATH = join(__dirname, "..", "mockTextract.json");
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = dirname(__filename$1);
+const MOCK_TEXTRACT_DOCUMENT_PATH = join(__dirname$1, "..", "mockTextract.json");
 // Setup
 let mockTextractContents;
 beforeAll(async () => {
@@ -1476,18 +873,18 @@ beforeAll(async () => {
 /**
  * Mock for MarkdownPage class from @jaypie/textract
  */
-const MarkdownPage = createMockWrappedObject(original$5.MarkdownPage, {
+const MarkdownPage = createMockWrappedObject(original$4.MarkdownPage, {
     class: true,
     fallback: () => {
         const mockDocument = new TextractDocument(JSON.parse(mockTextractContents));
         // Double type assertion needed to bridge incompatible types
-        return new original$5.MarkdownPage(mockDocument.pageNumber(1));
+        return new original$4.MarkdownPage(mockDocument.pageNumber(1));
     },
 });
 /**
  * Mock for textractJsonToMarkdown function from @jaypie/textract
  */
-const textractJsonToMarkdown = createMockWrappedFunction(original$5.textractJsonToMarkdown, `_MOCK_TEXTRACT_JSON_TO_MARKDOWN_[${TAG}]`);
+const textractJsonToMarkdown = createMockWrappedFunction(original$4.textractJsonToMarkdown, `_MOCK_TEXTRACT_JSON_TO_MARKDOWN_[${TAG}]`);
 // Export default for convenience
 var textract = {
     MarkdownPage,
@@ -1524,5 +921,5 @@ const mock = {
     ...textract$1,
 };
 
-export { BadGatewayError, BadRequestError, ConfigurationError, DATADOG, ERROR$1 as ERROR, EXPRESS, FORMAT, ForbiddenError, GatewayTimeoutError, GeminiProvider, GoneError, HTTP$1 as HTTP, IllogicalError, InternalError, JAYPIE, JaypieToolkit, LEVEL, LLM, Llm, LlmMessageRole, LlmMessageType, Logger, MarkdownPage, MethodNotAllowedError, MultiError, NotFoundError, NotImplementedError, OpenRouterProvider, 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 };
+export { BadGatewayError, BadRequestError, ConfigurationError, CorsError, DATADOG, EXPRESS, ForbiddenError, GatewayTimeoutError, GeminiProvider, GoneError, HTTP$1 as HTTP, IllogicalError, InternalError, JAYPIE, JaypieError, JaypieToolkit, LLM, Llm, LlmMessageRole, LlmMessageType, MarkdownPage, MethodNotAllowedError, MultiError, NotFoundError, NotImplementedError, OpenRouterProvider, PROJECT, ProjectError, ProjectMultiError, RejectedError, TeapotError, TooManyRequestsError, Toolkit, UnauthorizedError, UnavailableError, UnhandledError, UnreachableCodeError, badRequestRoute, cloneDeep, connect, connectFromSecretEnv, cors, createLogger, mock as default, disconnect, echoRoute, envBoolean, envsKey, errorFromStatusCode, expressHandler, expressHttpCodeHandler, forbiddenRoute, force, formatError, getEnvSecret, getHeaderFrom, getMessages, getObjectKeyCaseInsensitive, getSecret, getSingletonMessage, getTextractJob, goneRoute, hasDatadogEnv, isClass, isJaypieError, isNodeTestEnv, isProductionEnv, jaypieErrorFromStatus, jaypieHandler, lambdaHandler, methodNotAllowedRoute, noContentRoute, notFoundRoute, notImplementedRoute, placeholders, resolveValue, safeParseFloat, sendBatchMessages, sendMessage, sendTextractJob, sleep, submitDistribution, submitMetric, submitMetricSet, textractJsonToMarkdown, toolkit, tools, uuid };
 //# sourceMappingURL=index.js.map