jaypie 1.1.77 → 1.2.0-rc.1

package/dist/cjs/aws.d.ts

@@ -0,0 +1,11 @@
+import type * as AwsTypes from "@jaypie/aws";
+type AwsModule = typeof AwsTypes;
+export declare function getEnvSecret(...args: Parameters<AwsModule["getEnvSecret"]>): ReturnType<AwsModule["getEnvSecret"]>;
+export declare function getMessages(...args: Parameters<AwsModule["getMessages"]>): ReturnType<AwsModule["getMessages"]>;
+export declare function getSecret(...args: Parameters<AwsModule["getSecret"]>): ReturnType<AwsModule["getSecret"]>;
+export declare function getSingletonMessage(...args: Parameters<AwsModule["getSingletonMessage"]>): ReturnType<AwsModule["getSingletonMessage"]>;
+export declare function getTextractJob(...args: Parameters<AwsModule["getTextractJob"]>): ReturnType<AwsModule["getTextractJob"]>;
+export declare function sendBatchMessages(...args: Parameters<AwsModule["sendBatchMessages"]>): ReturnType<AwsModule["sendBatchMessages"]>;
+export declare function sendMessage(...args: Parameters<AwsModule["sendMessage"]>): ReturnType<AwsModule["sendMessage"]>;
+export declare function sendTextractJob(...args: Parameters<AwsModule["sendTextractJob"]>): ReturnType<AwsModule["sendTextractJob"]>;
+export {};

package/dist/cjs/datadog.d.ts

@@ -0,0 +1,8 @@
+import type * as DatadogTypes from "@jaypie/datadog";
+type DatadogModule = typeof DatadogTypes;
+export declare const DATADOG: DatadogModule["DATADOG"];
+export declare function hasDatadogEnv(...args: Parameters<DatadogModule["hasDatadogEnv"]>): ReturnType<DatadogModule["hasDatadogEnv"]>;
+export declare function submitDistribution(...args: Parameters<DatadogModule["submitDistribution"]>): ReturnType<DatadogModule["submitDistribution"]>;
+export declare function submitMetric(...args: Parameters<DatadogModule["submitMetric"]>): ReturnType<DatadogModule["submitMetric"]>;
+export declare function submitMetricSet(...args: Parameters<DatadogModule["submitMetricSet"]>): ReturnType<DatadogModule["submitMetricSet"]>;
+export {};

package/dist/cjs/error.constant.d.ts

@@ -0,0 +1,64 @@
+export declare const ERROR: {
+    readonly MESSAGE: {
+        readonly BAD_GATEWAY: "An unexpected error occurred on an upstream resource";
+        readonly BAD_REQUEST: "The request was not properly formatted";
+        readonly CONFIGURATION_ERROR: "The application responding to the request encountered a configuration error";
+        readonly CORS_ERROR: "The requesting origin is not authorized to this resource";
+        readonly FORBIDDEN: "Access to this resource is not authorized";
+        readonly GATEWAY_TIMEOUT: "The connection timed out waiting for an upstream resource";
+        readonly GONE: "The requested resource is no longer available";
+        readonly ILLOGICAL: "The application encountered an illogical condition while processing the request";
+        readonly INTERNAL_ERROR: "An unexpected error occurred and the request was unable to complete";
+        readonly METHOD_NOT_ALLOWED: "The requested method is not allowed";
+        readonly NOT_FOUND: "The requested resource was not found";
+        readonly NOT_IMPLEMENTED: "The request was understood but the resource is not implemented";
+        readonly REJECTED: "The request was rejected prior to processing";
+        readonly TEAPOT: "This resource is a teapot incapable of processing the request";
+        readonly TOO_MANY_REQUESTS: "The requesting origin exceeded the request limit";
+        readonly UNAUTHORIZED: "The request did not include valid authentication credentials";
+        readonly UNAVAILABLE: "The requested resource is temporarily unavailable";
+        readonly UNHANDLED: "An unhandled error occurred and the request was unable to complete";
+        readonly UNREACHABLE_CODE: "The application encountered an unreachable condition while processing the request";
+    };
+    readonly TITLE: {
+        readonly BAD_GATEWAY: "Bad Gateway";
+        readonly BAD_REQUEST: "Bad Request";
+        readonly CONFIGURATION_ERROR: "Internal Configuration Error";
+        readonly CORS_ERROR: "Unauthorized Origin";
+        readonly FORBIDDEN: "Forbidden";
+        readonly GATEWAY_TIMEOUT: "Gateway Timeout";
+        readonly GONE: "Gone";
+        readonly INTERNAL_ERROR: "Internal Application Error";
+        readonly METHOD_NOT_ALLOWED: "Method Not Allowed";
+        readonly NOT_FOUND: "Not Found";
+        readonly NOT_IMPLEMENTED: "Not Implemented";
+        readonly REJECTED: "Request Rejected";
+        readonly TEAPOT: "Teapot";
+        readonly TOO_MANY_REQUESTS: "Too Many Requests";
+        readonly UNAUTHORIZED: "Service Unauthorized";
+        readonly UNAVAILABLE: "Service Unavailable";
+    };
+    readonly TYPE: {
+        readonly BAD_GATEWAY: "BAD_GATEWAY";
+        readonly BAD_REQUEST: "BAD_REQUEST";
+        readonly CONFIGURATION_ERROR: "CONFIGURATION_ERROR";
+        readonly CORS_ERROR: "CORS_ERROR";
+        readonly FORBIDDEN: "FORBIDDEN";
+        readonly GATEWAY_TIMEOUT: "GATEWAY_TIMEOUT";
+        readonly GONE: "GONE";
+        readonly ILLOGICAL: "ILLOGICAL";
+        readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+        readonly METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED";
+        readonly MULTI_ERROR: "MULTI_ERROR";
+        readonly NOT_FOUND: "NOT_FOUND";
+        readonly NOT_IMPLEMENTED: "NOT_IMPLEMENTED";
+        readonly REJECTED: "REJECTED";
+        readonly TEAPOT: "TEAPOT";
+        readonly TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS";
+        readonly UNAUTHORIZED: "UNAUTHORIZED";
+        readonly UNAVAILABLE: "UNAVAILABLE";
+        readonly UNHANDLED: "UNHANDLED";
+        readonly UNKNOWN_TYPE: "UNKNOWN_TYPE";
+        readonly UNREACHABLE_CODE: "UNREACHABLE_CODE";
+    };
+};

package/dist/cjs/express.d.ts

@@ -0,0 +1,15 @@
+import type * as ExpressTypes from "@jaypie/express";
+type ExpressModule = typeof ExpressTypes;
+export type { CorsConfig, ExpressHandlerLocals, ExpressHandlerOptions, JaypieHandlerSetup, JaypieHandlerTeardown, JaypieHandlerValidate, } from "@jaypie/express";
+export declare const EXPRESS: ExpressModule["EXPRESS"];
+export declare function cors(...args: Parameters<ExpressModule["cors"]>): ReturnType<ExpressModule["cors"]>;
+export declare function expressHandler(...args: Parameters<ExpressModule["expressHandler"]>): ReturnType<ExpressModule["expressHandler"]>;
+export declare function expressHttpCodeHandler(...args: Parameters<ExpressModule["expressHttpCodeHandler"]>): ReturnType<ExpressModule["expressHttpCodeHandler"]>;
+export declare const badRequestRoute: ExpressModule["badRequestRoute"];
+export declare const echoRoute: ExpressModule["echoRoute"];
+export declare const forbiddenRoute: ExpressModule["forbiddenRoute"];
+export declare const goneRoute: ExpressModule["goneRoute"];
+export declare const methodNotAllowedRoute: ExpressModule["methodNotAllowedRoute"];
+export declare const noContentRoute: ExpressModule["noContentRoute"];
+export declare const notFoundRoute: ExpressModule["notFoundRoute"];
+export declare const notImplementedRoute: ExpressModule["notImplementedRoute"];

package/dist/cjs/index.cjs

@@ -1,62 +1,447 @@
 'use strict';
 
-var core = require('@jaypie/core');
-var aws = require('@jaypie/aws');
-var datadog = require('@jaypie/datadog');
-var express = require('@jaypie/express');
-var lambda = require('@jaypie/lambda');
-var llm = require('@jaypie/llm');
+var errors = require('@jaypie/errors');
 var kit = require('@jaypie/kit');
-var mongoose = require('@jaypie/mongoose');
-
-
-
-Object.keys(core).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return core[k]; }
-	});
-});
-Object.keys(aws).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return aws[k]; }
-	});
-});
-Object.keys(datadog).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return datadog[k]; }
-	});
-});
-Object.keys(express).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return express[k]; }
-	});
-});
-Object.keys(lambda).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return lambda[k]; }
-	});
-});
-Object.keys(llm).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return llm[k]; }
-	});
+var logger = require('@jaypie/logger');
+var uuid = require('uuid');
+var module$1 = require('module');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// ERROR constant - mirror from @jaypie/errors types
+const ERROR = {
+    MESSAGE: {
+        BAD_GATEWAY: "An unexpected error occurred on an upstream resource",
+        BAD_REQUEST: "The request was not properly formatted",
+        CONFIGURATION_ERROR: "The application responding to the request encountered a configuration error",
+        CORS_ERROR: "The requesting origin is not authorized to this resource",
+        FORBIDDEN: "Access to this resource is not authorized",
+        GATEWAY_TIMEOUT: "The connection timed out waiting for an upstream resource",
+        GONE: "The requested resource is no longer available",
+        ILLOGICAL: "The application encountered an illogical condition while processing the request",
+        INTERNAL_ERROR: "An unexpected error occurred and the request was unable to complete",
+        METHOD_NOT_ALLOWED: "The requested method is not allowed",
+        NOT_FOUND: "The requested resource was not found",
+        NOT_IMPLEMENTED: "The request was understood but the resource is not implemented",
+        REJECTED: "The request was rejected prior to processing",
+        TEAPOT: "This resource is a teapot incapable of processing the request",
+        TOO_MANY_REQUESTS: "The requesting origin exceeded the request limit",
+        UNAUTHORIZED: "The request did not include valid authentication credentials",
+        UNAVAILABLE: "The requested resource is temporarily unavailable",
+        UNHANDLED: "An unhandled error occurred and the request was unable to complete",
+        UNREACHABLE_CODE: "The application encountered an unreachable condition while processing the request",
+    },
+    TITLE: {
+        BAD_GATEWAY: "Bad Gateway",
+        BAD_REQUEST: "Bad Request",
+        CONFIGURATION_ERROR: "Internal Configuration Error",
+        CORS_ERROR: "Unauthorized Origin",
+        FORBIDDEN: "Forbidden",
+        GATEWAY_TIMEOUT: "Gateway Timeout",
+        GONE: "Gone",
+        INTERNAL_ERROR: "Internal Application Error",
+        METHOD_NOT_ALLOWED: "Method Not Allowed",
+        NOT_FOUND: "Not Found",
+        NOT_IMPLEMENTED: "Not Implemented",
+        REJECTED: "Request Rejected",
+        TEAPOT: "Teapot",
+        TOO_MANY_REQUESTS: "Too Many Requests",
+        UNAUTHORIZED: "Service Unauthorized",
+        UNAVAILABLE: "Service Unavailable",
+    },
+    TYPE: {
+        BAD_GATEWAY: "BAD_GATEWAY",
+        BAD_REQUEST: "BAD_REQUEST",
+        CONFIGURATION_ERROR: "CONFIGURATION_ERROR",
+        CORS_ERROR: "CORS_ERROR",
+        FORBIDDEN: "FORBIDDEN",
+        GATEWAY_TIMEOUT: "GATEWAY_TIMEOUT",
+        GONE: "GONE",
+        ILLOGICAL: "ILLOGICAL",
+        INTERNAL_ERROR: "INTERNAL_ERROR",
+        METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED",
+        MULTI_ERROR: "MULTI_ERROR",
+        NOT_FOUND: "NOT_FOUND",
+        NOT_IMPLEMENTED: "NOT_IMPLEMENTED",
+        REJECTED: "REJECTED",
+        TEAPOT: "TEAPOT",
+        TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS",
+        UNAUTHORIZED: "UNAUTHORIZED",
+        UNAVAILABLE: "UNAVAILABLE",
+        UNHANDLED: "UNHANDLED",
+        UNKNOWN_TYPE: "UNKNOWN_TYPE",
+        UNREACHABLE_CODE: "UNREACHABLE_CODE",
+    },
+};
+
+// Using createRequire for synchronous package loading - required for lazy loading pattern
+const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+const packageCache = new Map();
+function loadPackage(packageName) {
+    if (packageCache.has(packageName)) {
+        return packageCache.get(packageName);
+    }
+    try {
+        // eslint-disable-next-line no-restricted-syntax
+        const pkg = require$1(packageName);
+        packageCache.set(packageName, pkg);
+        return pkg;
+    }
+    catch (error) {
+        const resolveAttempt = safeResolve(packageName);
+        const err = error;
+        // eslint-disable-next-line no-console
+        console.error(`[jaypie] loadPackage failed for "${packageName}"`, {
+            importMetaUrl: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)),
+            resolveAttempt,
+            errorCode: err.code,
+            errorMessage: err.message,
+        });
+        throw new errors.ConfigurationError(`${packageName} is required but not installed. Run: npm install ${packageName}`);
+    }
+}
+function safeResolve(packageName) {
+    try {
+        return require$1.resolve(packageName);
+    }
+    catch {
+        return null;
+    }
+}
+
+function getEnvSecret(...args) {
+    return loadPackage("@jaypie/aws").getEnvSecret(...args);
+}
+function getMessages(...args) {
+    return loadPackage("@jaypie/aws").getMessages(...args);
+}
+function getSecret(...args) {
+    return loadPackage("@jaypie/aws").getSecret(...args);
+}
+function getSingletonMessage(...args) {
+    return loadPackage("@jaypie/aws").getSingletonMessage(...args);
+}
+function getTextractJob(...args) {
+    return loadPackage("@jaypie/aws").getTextractJob(...args);
+}
+function sendBatchMessages(...args) {
+    return loadPackage("@jaypie/aws").sendBatchMessages(...args);
+}
+function sendMessage(...args) {
+    return loadPackage("@jaypie/aws").sendMessage(...args);
+}
+function sendTextractJob(...args) {
+    return loadPackage("@jaypie/aws").sendTextractJob(...args);
+}
+
+// Re-export constant via getter to lazy load
+const DATADOG = new Proxy({}, {
+    get(_, prop) {
+        return loadPackage("@jaypie/datadog").DATADOG[prop];
+    },
+});
+function hasDatadogEnv(...args) {
+    return loadPackage("@jaypie/datadog").hasDatadogEnv(...args);
+}
+function submitDistribution(...args) {
+    return loadPackage("@jaypie/datadog").submitDistribution(...args);
+}
+function submitMetric(...args) {
+    return loadPackage("@jaypie/datadog").submitMetric(...args);
+}
+function submitMetricSet(...args) {
+    return loadPackage("@jaypie/datadog").submitMetricSet(...args);
+}
+
+// Re-export constant via getter to lazy load
+const EXPRESS = new Proxy({}, {
+    get(_, prop) {
+        return loadPackage("@jaypie/express").EXPRESS[prop];
+    },
+});
+function cors(...args) {
+    return loadPackage("@jaypie/express").cors(...args);
+}
+function expressHandler(...args) {
+    return loadPackage("@jaypie/express").expressHandler(...args);
+}
+function expressHttpCodeHandler(...args) {
+    return loadPackage("@jaypie/express").expressHttpCodeHandler(...args);
+}
+// Route exports - these are pre-created handlers, so we use getters
+const badRequestRoute = new Proxy((() => { }), {
+    apply(_, thisArg, args) {
+        return Reflect.apply(loadPackage("@jaypie/express").badRequestRoute, thisArg, args);
+    },
+    get(_, prop) {
+        const route = loadPackage("@jaypie/express")
+            .badRequestRoute;
+        return route[prop];
+    },
+});
+const echoRoute = new Proxy((() => { }), {
+    apply(_, thisArg, args) {
+        return Reflect.apply(loadPackage("@jaypie/express").echoRoute, thisArg, args);
+    },
+    get(_, prop) {
+        const route = loadPackage("@jaypie/express")
+            .echoRoute;
+        return route[prop];
+    },
+});
+const forbiddenRoute = new Proxy((() => { }), {
+    apply(_, thisArg, args) {
+        return Reflect.apply(loadPackage("@jaypie/express").forbiddenRoute, thisArg, args);
+    },
+    get(_, prop) {
+        const route = loadPackage("@jaypie/express")
+            .forbiddenRoute;
+        return route[prop];
+    },
+});
+const goneRoute = new Proxy((() => { }), {
+    apply(_, thisArg, args) {
+        return Reflect.apply(loadPackage("@jaypie/express").goneRoute, thisArg, args);
+    },
+    get(_, prop) {
+        const route = loadPackage("@jaypie/express")
+            .goneRoute;
+        return route[prop];
+    },
+});
+const methodNotAllowedRoute = new Proxy((() => { }), {
+    apply(_, thisArg, args) {
+        return Reflect.apply(loadPackage("@jaypie/express").methodNotAllowedRoute, thisArg, args);
+    },
+    get(_, prop) {
+        const route = loadPackage("@jaypie/express")
+            .methodNotAllowedRoute;
+        return route[prop];
+    },
+});
+const noContentRoute = new Proxy((() => { }), {
+    apply(_, thisArg, args) {
+        return Reflect.apply(loadPackage("@jaypie/express").noContentRoute, thisArg, args);
+    },
+    get(_, prop) {
+        const route = loadPackage("@jaypie/express")
+            .noContentRoute;
+        return route[prop];
+    },
+});
+const notFoundRoute = new Proxy((() => { }), {
+    apply(_, thisArg, args) {
+        return Reflect.apply(loadPackage("@jaypie/express").notFoundRoute, thisArg, args);
+    },
+    get(_, prop) {
+        const route = loadPackage("@jaypie/express")
+            .notFoundRoute;
+        return route[prop];
+    },
+});
+const notImplementedRoute = new Proxy((() => { }), {
+    apply(_, thisArg, args) {
+        return Reflect.apply(loadPackage("@jaypie/express").notImplementedRoute, thisArg, args);
+    },
+    get(_, prop) {
+        const route = loadPackage("@jaypie/express")
+            .notImplementedRoute;
+        return route[prop];
+    },
+});
+
+function lambdaHandler(...args) {
+    return loadPackage("@jaypie/lambda").lambdaHandler(...args);
+}
+
+// Re-export enums via getters
+const LlmMessageRole = new Proxy({}, {
+    get(_, prop) {
+        return loadPackage("@jaypie/llm").LlmMessageRole[prop];
+    },
+});
+const LlmMessageType = new Proxy({}, {
+    get(_, prop) {
+        return loadPackage("@jaypie/llm").LlmMessageType[prop];
+    },
+});
+// Re-export LLM constants namespace via getter
+const LLM = new Proxy({}, {
+    get(_, prop) {
+        return loadPackage("@jaypie/llm").LLM[prop];
+    },
+});
+// Llm class wrapper
+const Llm = new Proxy(function () { }, {
+    construct(_, args) {
+        const LlmClass = loadPackage("@jaypie/llm").Llm;
+        return new LlmClass(...args);
+    },
+    get(_, prop) {
+        const LlmClass = loadPackage("@jaypie/llm")
+            .Llm;
+        return LlmClass[prop];
+    },
+});
+// Toolkit exports
+const JaypieToolkit = new Proxy(function () { }, {
+    construct(_, args) {
+        const ToolkitClass = loadPackage("@jaypie/llm").JaypieToolkit;
+        return new ToolkitClass(...args);
+    },
+    get(_, prop) {
+        const ToolkitClass = loadPackage("@jaypie/llm")
+            .JaypieToolkit;
+        return ToolkitClass[prop];
+    },
+});
+const Toolkit = new Proxy(function () { }, {
+    construct(_, args) {
+        const ToolkitClass = loadPackage("@jaypie/llm").Toolkit;
+        return new ToolkitClass(...args);
+    },
+    get(_, prop) {
+        const ToolkitClass = loadPackage("@jaypie/llm")
+            .Toolkit;
+        return ToolkitClass[prop];
+    },
+});
+// toolkit and tools are objects/instances
+const toolkit = new Proxy({}, {
+    get(_, prop) {
+        const toolkitObj = loadPackage("@jaypie/llm")
+            .toolkit;
+        return toolkitObj[prop];
+    },
+});
+const tools = new Proxy({}, {
+    get(_, prop) {
+        const toolsObj = loadPackage("@jaypie/llm")
+            .tools;
+        return toolsObj[prop];
+    },
+});
+// Provider exports
+const GeminiProvider = new Proxy(function () { }, {
+    construct(_, args) {
+        const ProviderClass = loadPackage("@jaypie/llm").GeminiProvider;
+        return new ProviderClass(...args);
+    },
+    get(_, prop) {
+        const ProviderClass = loadPackage("@jaypie/llm")
+            .GeminiProvider;
+        return ProviderClass[prop];
+    },
+});
+const OpenRouterProvider = new Proxy(function () { }, {
+    construct(_, args) {
+        const ProviderClass = loadPackage("@jaypie/llm").OpenRouterProvider;
+        return new ProviderClass(...args);
+    },
+    get(_, prop) {
+        const ProviderClass = loadPackage("@jaypie/llm")
+            .OpenRouterProvider;
+        return ProviderClass[prop];
+    },
+});
+
+function connect(...args) {
+    return loadPackage("@jaypie/mongoose").connect(...args);
+}
+function connectFromSecretEnv(...args) {
+    return loadPackage("@jaypie/mongoose").connectFromSecretEnv(...args);
+}
+function disconnect() {
+    return loadPackage("@jaypie/mongoose").disconnect();
+}
+// Re-export mongoose via getter to lazy load
+const mongoose = new Proxy({}, {
+    get(_, prop) {
+        const mongoosePkg = loadPackage("@jaypie/mongoose")
+            .mongoose;
+        return mongoosePkg[prop];
+    },
+    apply(_, thisArg, args) {
+        const mongoosePkg = loadPackage("@jaypie/mongoose")
+            .mongoose;
+        return Reflect.apply(mongoosePkg, thisArg, args);
+    },
+});
+
+Object.defineProperty(exports, "MultiError", {
+    enumerable: true,
+    get: function () { return errors.InternalError; }
+});
+Object.defineProperty(exports, "ProjectError", {
+    enumerable: true,
+    get: function () { return errors.InternalError; }
+});
+Object.defineProperty(exports, "ProjectMultiError", {
+    enumerable: true,
+    get: function () { return errors.InternalError; }
+});
+Object.defineProperty(exports, "errorFromStatusCode", {
+    enumerable: true,
+    get: function () { return errors.jaypieErrorFromStatus; }
+});
+Object.defineProperty(exports, "log", {
+    enumerable: true,
+    get: function () { return logger.log; }
+});
+Object.defineProperty(exports, "uuid", {
+    enumerable: true,
+    get: function () { return uuid.v4; }
+});
+exports.DATADOG = DATADOG;
+exports.ERROR = ERROR;
+exports.EXPRESS = EXPRESS;
+exports.GeminiProvider = GeminiProvider;
+exports.JaypieToolkit = JaypieToolkit;
+exports.LLM = LLM;
+exports.Llm = Llm;
+exports.LlmMessageRole = LlmMessageRole;
+exports.LlmMessageType = LlmMessageType;
+exports.OpenRouterProvider = OpenRouterProvider;
+exports.Toolkit = Toolkit;
+exports.badRequestRoute = badRequestRoute;
+exports.connect = connect;
+exports.connectFromSecretEnv = connectFromSecretEnv;
+exports.cors = cors;
+exports.disconnect = disconnect;
+exports.echoRoute = echoRoute;
+exports.expressHandler = expressHandler;
+exports.expressHttpCodeHandler = expressHttpCodeHandler;
+exports.forbiddenRoute = forbiddenRoute;
+exports.getEnvSecret = getEnvSecret;
+exports.getMessages = getMessages;
+exports.getSecret = getSecret;
+exports.getSingletonMessage = getSingletonMessage;
+exports.getTextractJob = getTextractJob;
+exports.goneRoute = goneRoute;
+exports.hasDatadogEnv = hasDatadogEnv;
+exports.lambdaHandler = lambdaHandler;
+exports.methodNotAllowedRoute = methodNotAllowedRoute;
+exports.mongoose = mongoose;
+exports.noContentRoute = noContentRoute;
+exports.notFoundRoute = notFoundRoute;
+exports.notImplementedRoute = notImplementedRoute;
+exports.sendBatchMessages = sendBatchMessages;
+exports.sendMessage = sendMessage;
+exports.sendTextractJob = sendTextractJob;
+exports.submitDistribution = submitDistribution;
+exports.submitMetric = submitMetric;
+exports.submitMetricSet = submitMetricSet;
+exports.toolkit = toolkit;
+exports.tools = tools;
+Object.keys(errors).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return errors[k]; }
+    });
 });
 Object.keys(kit).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return kit[k]; }
-	});
-});
-Object.keys(mongoose).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return mongoose[k]; }
-	});
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return kit[k]; }
+    });
 });
 //# sourceMappingURL=index.cjs.map