@adobe-commerce/aio-toolkit 1.0.8 → 1.0.9

package/dist/index.mjs

@@ -1,8 +1,433 @@
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// src/framework/runtime-action/index.ts
-import { Core } from "@adobe/aio-sdk";
+// node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
+var _globalThis;
+var init_globalThis = __esm({
+  "node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js"() {
+    "use strict";
+    _globalThis = typeof globalThis === "object" ? globalThis : global;
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/platform/node/index.js
+var init_node = __esm({
+  "node_modules/@opentelemetry/api/build/esm/platform/node/index.js"() {
+    "use strict";
+    init_globalThis();
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/platform/index.js
+var init_platform = __esm({
+  "node_modules/@opentelemetry/api/build/esm/platform/index.js"() {
+    "use strict";
+    init_node();
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/version.js
+var VERSION;
+var init_version = __esm({
+  "node_modules/@opentelemetry/api/build/esm/version.js"() {
+    "use strict";
+    VERSION = "1.9.0";
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/internal/semver.js
+function _makeCompatibilityCheck(ownVersion) {
+  var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  var rejectedVersions = /* @__PURE__ */ new Set();
+  var myVersionMatch = ownVersion.match(re);
+  if (!myVersionMatch) {
+    return function() {
+      return false;
+    };
+  }
+  var ownVersionParsed = {
+    major: +myVersionMatch[1],
+    minor: +myVersionMatch[2],
+    patch: +myVersionMatch[3],
+    prerelease: myVersionMatch[4]
+  };
+  if (ownVersionParsed.prerelease != null) {
+    return /* @__PURE__ */ __name(function isExactmatch(globalVersion) {
+      return globalVersion === ownVersion;
+    }, "isExactmatch");
+  }
+  function _reject(v) {
+    rejectedVersions.add(v);
+    return false;
+  }
+  __name(_reject, "_reject");
+  function _accept(v) {
+    acceptedVersions.add(v);
+    return true;
+  }
+  __name(_accept, "_accept");
+  return /* @__PURE__ */ __name(function isCompatible2(globalVersion) {
+    if (acceptedVersions.has(globalVersion)) {
+      return true;
+    }
+    if (rejectedVersions.has(globalVersion)) {
+      return false;
+    }
+    var globalVersionMatch = globalVersion.match(re);
+    if (!globalVersionMatch) {
+      return _reject(globalVersion);
+    }
+    var globalVersionParsed = {
+      major: +globalVersionMatch[1],
+      minor: +globalVersionMatch[2],
+      patch: +globalVersionMatch[3],
+      prerelease: globalVersionMatch[4]
+    };
+    if (globalVersionParsed.prerelease != null) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major !== globalVersionParsed.major) {
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.major === 0) {
+      if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+        return _accept(globalVersion);
+      }
+      return _reject(globalVersion);
+    }
+    if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+      return _accept(globalVersion);
+    }
+    return _reject(globalVersion);
+  }, "isCompatible");
+}
+var re, isCompatible;
+var init_semver = __esm({
+  "node_modules/@opentelemetry/api/build/esm/internal/semver.js"() {
+    "use strict";
+    init_version();
+    re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+    __name(_makeCompatibilityCheck, "_makeCompatibilityCheck");
+    isCompatible = _makeCompatibilityCheck(VERSION);
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+function registerGlobal(type, instance, diag2, allowOverride) {
+  var _a;
+  if (allowOverride === void 0) {
+    allowOverride = false;
+  }
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+    version: VERSION
+  };
+  if (!allowOverride && api[type]) {
+    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
+    diag2.error(err.stack || err.message);
+    return false;
+  }
+  if (api.version !== VERSION) {
+    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
+    diag2.error(err.stack || err.message);
+    return false;
+  }
+  api[type] = instance;
+  diag2.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
+  return true;
+}
+function getGlobal(type) {
+  var _a, _b;
+  var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+  if (!globalVersion || !isCompatible(globalVersion)) {
+    return;
+  }
+  return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag2) {
+  diag2.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  if (api) {
+    delete api[type];
+  }
+}
+var major, GLOBAL_OPENTELEMETRY_API_KEY, _global;
+var init_global_utils = __esm({
+  "node_modules/@opentelemetry/api/build/esm/internal/global-utils.js"() {
+    "use strict";
+    init_platform();
+    init_version();
+    init_semver();
+    major = VERSION.split(".")[0];
+    GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
+    _global = _globalThis;
+    __name(registerGlobal, "registerGlobal");
+    __name(getGlobal, "getGlobal");
+    __name(unregisterGlobal, "unregisterGlobal");
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+function logProxy(funcName, namespace, args) {
+  var logger = getGlobal("diag");
+  if (!logger) {
+    return;
+  }
+  args.unshift(namespace);
+  return logger[funcName].apply(logger, __spreadArray([], __read(args), false));
+}
+var __read, __spreadArray, DiagComponentLogger;
+var init_ComponentLogger = __esm({
+  "node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js"() {
+    "use strict";
+    init_global_utils();
+    __read = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    __spreadArray = function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    DiagComponentLogger = /** @class */
+    (function() {
+      function DiagComponentLogger2(props) {
+        this._namespace = props.namespace || "DiagComponentLogger";
+      }
+      __name(DiagComponentLogger2, "DiagComponentLogger");
+      DiagComponentLogger2.prototype.debug = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("debug", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.error = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("error", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.info = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("info", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.warn = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("warn", this._namespace, args);
+      };
+      DiagComponentLogger2.prototype.verbose = function() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return logProxy("verbose", this._namespace, args);
+      };
+      return DiagComponentLogger2;
+    })();
+    __name(logProxy, "logProxy");
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/diag/types.js
+var DiagLogLevel;
+var init_types = __esm({
+  "node_modules/@opentelemetry/api/build/esm/diag/types.js"() {
+    "use strict";
+    (function(DiagLogLevel2) {
+      DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+      DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+      DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+      DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+      DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+      DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+      DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+    })(DiagLogLevel || (DiagLogLevel = {}));
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+function createLogLevelDiagLogger(maxLevel, logger) {
+  if (maxLevel < DiagLogLevel.NONE) {
+    maxLevel = DiagLogLevel.NONE;
+  } else if (maxLevel > DiagLogLevel.ALL) {
+    maxLevel = DiagLogLevel.ALL;
+  }
+  logger = logger || {};
+  function _filterFunc(funcName, theLevel) {
+    var theFunc = logger[funcName];
+    if (typeof theFunc === "function" && maxLevel >= theLevel) {
+      return theFunc.bind(logger);
+    }
+    return function() {
+    };
+  }
+  __name(_filterFunc, "_filterFunc");
+  return {
+    error: _filterFunc("error", DiagLogLevel.ERROR),
+    warn: _filterFunc("warn", DiagLogLevel.WARN),
+    info: _filterFunc("info", DiagLogLevel.INFO),
+    debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+    verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+  };
+}
+var init_logLevelLogger = __esm({
+  "node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js"() {
+    "use strict";
+    init_types();
+    __name(createLogLevelDiagLogger, "createLogLevelDiagLogger");
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/api/diag.js
+var __read2, __spreadArray2, API_NAME, DiagAPI;
+var init_diag = __esm({
+  "node_modules/@opentelemetry/api/build/esm/api/diag.js"() {
+    "use strict";
+    init_ComponentLogger();
+    init_logLevelLogger();
+    init_types();
+    init_global_utils();
+    __read2 = function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    __spreadArray2 = function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    API_NAME = "diag";
+    DiagAPI = /** @class */
+    (function() {
+      function DiagAPI2() {
+        function _logProxy(funcName) {
+          return function() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
+            }
+            var logger = getGlobal("diag");
+            if (!logger)
+              return;
+            return logger[funcName].apply(logger, __spreadArray2([], __read2(args), false));
+          };
+        }
+        __name(_logProxy, "_logProxy");
+        var self = this;
+        var setLogger = /* @__PURE__ */ __name(function(logger, optionsOrLogLevel) {
+          var _a, _b, _c;
+          if (optionsOrLogLevel === void 0) {
+            optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
+          }
+          if (logger === self) {
+            var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+            self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+            return false;
+          }
+          if (typeof optionsOrLogLevel === "number") {
+            optionsOrLogLevel = {
+              logLevel: optionsOrLogLevel
+            };
+          }
+          var oldLogger = getGlobal("diag");
+          var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+          if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+            var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+            oldLogger.warn("Current logger will be overwritten from " + stack);
+            newLogger.warn("Current logger will overwrite one already registered from " + stack);
+          }
+          return registerGlobal("diag", newLogger, self, true);
+        }, "setLogger");
+        self.setLogger = setLogger;
+        self.disable = function() {
+          unregisterGlobal(API_NAME, self);
+        };
+        self.createComponentLogger = function(options) {
+          return new DiagComponentLogger(options);
+        };
+        self.verbose = _logProxy("verbose");
+        self.debug = _logProxy("debug");
+        self.info = _logProxy("info");
+        self.warn = _logProxy("warn");
+        self.error = _logProxy("error");
+      }
+      __name(DiagAPI2, "DiagAPI");
+      DiagAPI2.instance = function() {
+        if (!this._instance) {
+          this._instance = new DiagAPI2();
+        }
+        return this._instance;
+      };
+      return DiagAPI2;
+    })();
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/diag-api.js
+var diag;
+var init_diag_api = __esm({
+  "node_modules/@opentelemetry/api/build/esm/diag-api.js"() {
+    "use strict";
+    init_diag();
+    diag = DiagAPI.instance();
+  }
+});
+
+// node_modules/@opentelemetry/api/build/esm/index.js
+var init_esm = __esm({
+  "node_modules/@opentelemetry/api/build/esm/index.js"() {
+    "use strict";
+    init_diag_api();
+  }
+});
 
 // src/framework/runtime-action/types.ts
 var HttpStatus = /* @__PURE__ */ ((HttpStatus2) => {
@@ -58,186 +483,1284 @@ var _RuntimeActionResponse = class _RuntimeActionResponse {
         body: {
           error
         }
-      }
+      }
+    };
+  }
+};
+__name(_RuntimeActionResponse, "RuntimeActionResponse");
+var RuntimeActionResponse = _RuntimeActionResponse;
+var response_default = RuntimeActionResponse;
+
+// src/framework/runtime-action/validator/index.ts
+var _Validator = class _Validator {
+  /**
+   * Returns the list of missing keys given an object and its required keys.
+   * A parameter is missing if its value is undefined or ''.
+   * A value of 0 or null is not considered as missing.
+   *
+   * @param obj object to check.
+   * @param required list of required keys.
+   *        Each element can be multi-level deep using a '.' separator e.g. 'myRequiredObj.myRequiredKey'
+   *
+   * @returns array
+   * @private
+   */
+  static getMissingKeys(obj, required) {
+    return required.filter((r) => {
+      const splits = r.split(".");
+      const last = splits[splits.length - 1];
+      const traverse = splits.slice(0, -1).reduce((tObj, split) => tObj[split] || {}, obj);
+      return last && (traverse[last] === void 0 || traverse[last] === "");
+    });
+  }
+  /**
+   * Returns the list of missing keys given an object and its required keys.
+   * A parameter is missing if its value is undefined or ''.
+   * A value of 0 or null is not considered as missing.
+   *
+   * @param params action input parameters.
+   * @param requiredHeaders list of required input headers.
+   * @param requiredParams list of required input parameters.
+   *        Each element can be multi-level deep using a '.' separator e.g. 'myRequiredObj.myRequiredKey'.
+   *
+   * @returns string|null if the return value is not null, then it holds an error message describing the missing inputs.
+   *
+   */
+  static checkMissingRequestInputs(params, requiredParams = [], requiredHeaders = []) {
+    let errorMessage = null;
+    requiredHeaders = requiredHeaders.map((h) => h.toLowerCase());
+    const normalizedHeaders = Object.keys(params.__ow_headers || {}).reduce(
+      (acc, key) => {
+        acc[key.toLowerCase()] = params.__ow_headers?.[key];
+        return acc;
+      },
+      {}
+    );
+    const missingHeaders = _Validator.getMissingKeys(normalizedHeaders, requiredHeaders);
+    if (missingHeaders.length > 0) {
+      errorMessage = `missing header(s) '${missingHeaders.join(", ")}'`;
+    }
+    const missingParams = _Validator.getMissingKeys(params, requiredParams);
+    if (missingParams.length > 0) {
+      if (errorMessage) {
+        errorMessage += " and ";
+      } else {
+        errorMessage = "";
+      }
+      errorMessage += `missing parameter(s) '${missingParams.join(", ")}'`;
+    }
+    return errorMessage;
+  }
+};
+__name(_Validator, "Validator");
+var Validator = _Validator;
+var validator_default = Validator;
+
+// src/framework/telemetry/index.ts
+import { Core } from "@adobe/aio-sdk";
+import { getLogger } from "@adobe/aio-lib-telemetry";
+
+// src/framework/telemetry/new-relic/index.ts
+import {
+  defineTelemetryConfig,
+  getPresetInstrumentations,
+  instrumentEntrypoint
+} from "@adobe/aio-lib-telemetry";
+
+// src/framework/telemetry/helpers/input-error/index.ts
+var _TelemetryInputError = class _TelemetryInputError extends Error {
+  /**
+   * Creates a new TelemetryInputError
+   *
+   * @param message - Descriptive error message explaining the validation failure
+   */
+  constructor(message) {
+    super(message);
+    this.name = "TelemetryInputError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _TelemetryInputError);
+    }
+  }
+};
+__name(_TelemetryInputError, "TelemetryInputError");
+var TelemetryInputError = _TelemetryInputError;
+
+// src/framework/telemetry/new-relic/validator/index.ts
+var _NewRelicTelemetryValidator = class _NewRelicTelemetryValidator {
+  /**
+   * Checks if New Relic telemetry is configured
+   *
+   * Returns true if:
+   * - ENABLE_TELEMETRY is explicitly set to true
+   * - NEW_RELIC_TELEMETRY is explicitly set to true
+   *
+   * This method does NOT validate the completeness of configuration,
+   * it only checks if the provider is enabled.
+   *
+   * @param params - Runtime parameters to check
+   * @returns true if New Relic telemetry is enabled, false otherwise
+   *
+   * @example
+   * ```typescript
+   * const validator = new NewRelicTelemetryValidator();
+   * const params = { ENABLE_TELEMETRY: true, NEW_RELIC_TELEMETRY: true };
+   * if (validator.isConfigured(params)) {
+   *   // New Relic is enabled, proceed with initialization
+   * }
+   * ```
+   */
+  isConfigured(params) {
+    return params.ENABLE_TELEMETRY === true && params.NEW_RELIC_TELEMETRY === true;
+  }
+  /**
+   * Validates New Relic specific parameters
+   *
+   * IMPORTANT: Only call this method after checking isConfigured() returns true.
+   * This method assumes New Relic telemetry is enabled and validates that
+   * all required parameters are present.
+   *
+   * Required parameters when New Relic is enabled:
+   * - NEW_RELIC_SERVICE_NAME must be provided
+   * - NEW_RELIC_LICENSE_KEY must be provided
+   *
+   * @param params - Runtime parameters to validate
+   * @throws {TelemetryInputError} If NEW_RELIC_SERVICE_NAME is missing
+   * @throws {TelemetryInputError} If NEW_RELIC_LICENSE_KEY is missing
+   *
+   * @example
+   * ```typescript
+   * const validator = new NewRelicTelemetryValidator();
+   * const params = {
+   *   ENABLE_TELEMETRY: true,
+   *   NEW_RELIC_TELEMETRY: true,
+   *   NEW_RELIC_SERVICE_NAME: "my-service",
+   *   NEW_RELIC_LICENSE_KEY: "license-key"
+   * };
+   *
+   * if (validator.isConfigured(params)) {
+   *   validator.validateConfiguration(params); // Validates required fields
+   * }
+   * ```
+   */
+  validateConfiguration(params) {
+    if (params.NEW_RELIC_SERVICE_NAME === void 0 || params.NEW_RELIC_SERVICE_NAME === null || params.NEW_RELIC_SERVICE_NAME === "") {
+      throw new TelemetryInputError("NEW_RELIC_SERVICE_NAME is required");
+    }
+    if (params.NEW_RELIC_LICENSE_KEY === void 0 || params.NEW_RELIC_LICENSE_KEY === null || params.NEW_RELIC_LICENSE_KEY === "") {
+      throw new TelemetryInputError("NEW_RELIC_LICENSE_KEY is required");
+    }
+  }
+};
+__name(_NewRelicTelemetryValidator, "NewRelicTelemetryValidator");
+var NewRelicTelemetryValidator = _NewRelicTelemetryValidator;
+
+// src/framework/telemetry/helpers/resource-factory/index.ts
+import { getAioRuntimeResource } from "@adobe/aio-lib-telemetry";
+
+// node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js
+init_esm();
+
+// node_modules/@opentelemetry/resources/build/esm/utils.js
+var isPromiseLike = /* @__PURE__ */ __name((val) => {
+  return val !== null && typeof val === "object" && typeof val.then === "function";
+}, "isPromiseLike");
+
+// node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js
+var _ResourceImpl = class _ResourceImpl {
+  constructor(resource, options) {
+    __publicField(this, "_rawAttributes");
+    __publicField(this, "_asyncAttributesPending", false);
+    __publicField(this, "_schemaUrl");
+    __publicField(this, "_memoizedAttributes");
+    const attributes = resource.attributes ?? {};
+    this._rawAttributes = Object.entries(attributes).map(([k, v]) => {
+      if (isPromiseLike(v)) {
+        this._asyncAttributesPending = true;
+      }
+      return [k, v];
+    });
+    this._rawAttributes = guardedRawAttributes(this._rawAttributes);
+    this._schemaUrl = validateSchemaUrl(options?.schemaUrl);
+  }
+  static FromAttributeList(attributes, options) {
+    const res = new _ResourceImpl({}, options);
+    res._rawAttributes = guardedRawAttributes(attributes);
+    res._asyncAttributesPending = attributes.filter(([_, val]) => isPromiseLike(val)).length > 0;
+    return res;
+  }
+  get asyncAttributesPending() {
+    return this._asyncAttributesPending;
+  }
+  async waitForAsyncAttributes() {
+    if (!this.asyncAttributesPending) {
+      return;
+    }
+    for (let i = 0; i < this._rawAttributes.length; i++) {
+      const [k, v] = this._rawAttributes[i];
+      this._rawAttributes[i] = [k, isPromiseLike(v) ? await v : v];
+    }
+    this._asyncAttributesPending = false;
+  }
+  get attributes() {
+    if (this.asyncAttributesPending) {
+      diag.error("Accessing resource attributes before async attributes settled");
+    }
+    if (this._memoizedAttributes) {
+      return this._memoizedAttributes;
+    }
+    const attrs = {};
+    for (const [k, v] of this._rawAttributes) {
+      if (isPromiseLike(v)) {
+        diag.debug(`Unsettled resource attribute ${k} skipped`);
+        continue;
+      }
+      if (v != null) {
+        attrs[k] ?? (attrs[k] = v);
+      }
+    }
+    if (!this._asyncAttributesPending) {
+      this._memoizedAttributes = attrs;
+    }
+    return attrs;
+  }
+  getRawAttributes() {
+    return this._rawAttributes;
+  }
+  get schemaUrl() {
+    return this._schemaUrl;
+  }
+  merge(resource) {
+    if (resource == null)
+      return this;
+    const mergedSchemaUrl = mergeSchemaUrl(this, resource);
+    const mergedOptions = mergedSchemaUrl ? { schemaUrl: mergedSchemaUrl } : void 0;
+    return _ResourceImpl.FromAttributeList([...resource.getRawAttributes(), ...this.getRawAttributes()], mergedOptions);
+  }
+};
+__name(_ResourceImpl, "ResourceImpl");
+var ResourceImpl = _ResourceImpl;
+function resourceFromAttributes(attributes, options) {
+  return ResourceImpl.FromAttributeList(Object.entries(attributes), options);
+}
+__name(resourceFromAttributes, "resourceFromAttributes");
+function guardedRawAttributes(attributes) {
+  return attributes.map(([k, v]) => {
+    if (isPromiseLike(v)) {
+      return [
+        k,
+        v.catch((err) => {
+          diag.debug("promise rejection for resource attribute: %s - %s", k, err);
+          return void 0;
+        })
+      ];
+    }
+    return [k, v];
+  });
+}
+__name(guardedRawAttributes, "guardedRawAttributes");
+function validateSchemaUrl(schemaUrl) {
+  if (typeof schemaUrl === "string" || schemaUrl === void 0) {
+    return schemaUrl;
+  }
+  diag.warn("Schema URL must be string or undefined, got %s. Schema URL will be ignored.", schemaUrl);
+  return void 0;
+}
+__name(validateSchemaUrl, "validateSchemaUrl");
+function mergeSchemaUrl(old, updating) {
+  const oldSchemaUrl = old?.schemaUrl;
+  const updatingSchemaUrl = updating?.schemaUrl;
+  const isOldEmpty = oldSchemaUrl === void 0 || oldSchemaUrl === "";
+  const isUpdatingEmpty = updatingSchemaUrl === void 0 || updatingSchemaUrl === "";
+  if (isOldEmpty) {
+    return updatingSchemaUrl;
+  }
+  if (isUpdatingEmpty) {
+    return oldSchemaUrl;
+  }
+  if (oldSchemaUrl === updatingSchemaUrl) {
+    return oldSchemaUrl;
+  }
+  diag.warn('Schema URL merge conflict: old resource has "%s", updating resource has "%s". Resulting resource will have undefined Schema URL.', oldSchemaUrl, updatingSchemaUrl);
+  return void 0;
+}
+__name(mergeSchemaUrl, "mergeSchemaUrl");
+
+// src/framework/telemetry/helpers/resource-factory/index.ts
+var _ResourceFactory = class _ResourceFactory {
+  /**
+   * Creates a resource with custom environment attributes
+   *
+   * Starts with the base Adobe I/O Runtime resource and optionally
+   * merges environment attributes. These attributes are useful for
+   * filtering and correlating telemetry data by deployment environment.
+   *
+   * Note: Request-specific data (like request IDs) should NOT be added to
+   * Resources as they are created once and reused across all requests.
+   * Use log attributes or span attributes for request-specific data.
+   *
+   * @param params - Runtime parameters containing optional ENVIRONMENT
+   * @param params.ENVIRONMENT - Environment name (e.g., "dev", "stage", "prod")
+   * @returns OpenTelemetry Resource with custom attributes if provided
+   *
+   * @example Without custom attributes
+   * ```typescript
+   * const factory = new ResourceFactory();
+   * const resource = factory.createWithEnvironment({});
+   * // Returns base Adobe I/O Runtime resource
+   * ```
+   *
+   * @example With environment
+   * ```typescript
+   * const factory = new ResourceFactory();
+   * const params = { ENVIRONMENT: "production" };
+   * const resource = factory.createWithEnvironment(params);
+   * // Returns resource with environment="production" attribute
+   * ```
+   */
+  createWithEnvironment(params) {
+    const baseResource = getAioRuntimeResource();
+    const customAttributes = {};
+    if (params.ENVIRONMENT) {
+      customAttributes.environment = params.ENVIRONMENT;
+    }
+    if (Object.keys(customAttributes).length === 0) {
+      return baseResource;
+    }
+    const customResource = resourceFromAttributes(
+      customAttributes
+    );
+    return baseResource.merge(customResource);
+  }
+};
+__name(_ResourceFactory, "ResourceFactory");
+var ResourceFactory = _ResourceFactory;
+
+// src/framework/telemetry/helpers/success-checker/index.ts
+var _SuccessChecker = class _SuccessChecker {
+  /**
+   * Determines if an action execution was successful
+   *
+   * Success criteria:
+   * - Response has statusCode 200
+   * - Body does not contain an exception operation
+   *
+   * @param result - The action execution result
+   * @returns true if successful, false otherwise
+   *
+   * @example Success case
+   * ```typescript
+   * const checker = new SuccessChecker();
+   * const result = { statusCode: 200, body: { data: 'success' } };
+   * checker.execute(result); // true
+   * ```
+   *
+   * @example Failure case - wrong status code
+   * ```typescript
+   * const checker = new SuccessChecker();
+   * const result = { statusCode: 500, body: { error: 'Internal error' } };
+   * checker.execute(result); // false
+   * ```
+   *
+   * @example Failure case - exception in body
+   * ```typescript
+   * const checker = new SuccessChecker();
+   * const result = { statusCode: 200, body: { op: 'exception', message: 'Error' } };
+   * checker.execute(result); // false
+   * ```
+   */
+  execute(result) {
+    if (!result || typeof result !== "object") {
+      return false;
+    }
+    const actionResult = result;
+    if (actionResult.statusCode !== 200) {
+      return false;
+    }
+    if (actionResult.body && typeof actionResult.body === "object") {
+      return actionResult.body.op !== "exception";
+    }
+    return true;
+  }
+};
+__name(_SuccessChecker, "SuccessChecker");
+var SuccessChecker = _SuccessChecker;
+
+// src/framework/telemetry/new-relic/index.ts
+import {
+  OTLPLogExporterProto,
+  OTLPMetricExporterProto,
+  OTLPTraceExporterProto,
+  PeriodicExportingMetricReader,
+  SimpleLogRecordProcessor
+} from "@adobe/aio-lib-telemetry/otel";
+
+// src/framework/telemetry/helpers/json-message-processor/index.ts
+var _JsonMessageProcessor = class _JsonMessageProcessor {
+  /**
+   * Creates a new JsonMessageProcessor
+   *
+   * @param wrappedProcessor - The log processor to wrap and enhance
+   *
+   * @example
+   * ```typescript
+   * const exporter = new OTLPLogExporterProto({
+   *   url: "https://otlp.nr-data.net/v1/logs",
+   *   headers: { "api-key": licenseKey }
+   * });
+   * const baseProcessor = new SimpleLogRecordProcessor(exporter);
+   * const processor = new JsonMessageProcessor(baseProcessor);
+   * ```
+   */
+  constructor(wrappedProcessor) {
+    this.wrappedProcessor = wrappedProcessor;
+  }
+  /**
+   * Parse JavaScript object notation and convert to proper object
+   *
+   * Handles Winston's util.inspect format which produces JavaScript
+   * object literals instead of JSON strings.
+   *
+   * Examples:
+   * - { key: 'value' } → {"key":"value"}
+   * - { 'accept-encoding': 'gzip' } → {"accept-encoding":"gzip"}
+   *
+   * @param str - JavaScript object notation string
+   * @returns Parsed object
+   * @throws Error if parsing fails
+   * @private
+   */
+  parseJavaScriptObjectNotation(str) {
+    const func = new Function("return (" + str + ")");
+    return func();
+  }
+  /**
+   * Flatten nested objects into dot-notation keys
+   *
+   * Converts nested structures like:
+   * { headers: { accept: '*' } }
+   *
+   * Into flat structure:
+   * { 'headers.accept': '*' }
+   *
+   * This makes all attributes searchable in observability platforms.
+   *
+   * @param obj - Object to flatten
+   * @param prefix - Current key prefix (used in recursion)
+   * @returns Flattened object with dot-notation keys
+   * @private
+   */
+  flattenObject(obj, prefix = "") {
+    const flattened = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const newKey = prefix ? `${prefix}.${key}` : key;
+      if (value === null || value === void 0) {
+        flattened[newKey] = value;
+      } else if (Array.isArray(value)) {
+        flattened[newKey] = JSON.stringify(value);
+      } else if (typeof value === "object") {
+        if (Object.keys(value).length === 0) {
+          continue;
+        }
+        const nested = this.flattenObject(value, newKey);
+        Object.assign(flattened, nested);
+      } else {
+        flattened[newKey] = value;
+      }
+    }
+    return flattened;
+  }
+  /**
+   * Processes a log record by parsing JSON messages and extracting attributes
+   *
+   * This method intercepts log records, attempts to parse structured data
+   * from the message body, and merges extracted properties as attributes.
+   * Additionally, it extracts the log level from the severity information
+   * and adds it as a 'level' attribute for easier querying.
+   *
+   * The enhanced log record is then passed to the wrapped processor.
+   *
+   * @param logRecord - The log record to process
+   *
+   * @remarks
+   * Processing steps:
+   * 1. Extract log level from severityText or severityNumber
+   * 2. Add 'level' attribute (debug, info, warn, error, etc.)
+   * 3. Parse JSON bodies that start with '{'
+   * 4. Extract properties as individual attributes
+   * 5. Preserve 'message' field as primary log body
+   *
+   * Error handling:
+   * - Silently handles parsing errors to avoid breaking the logging pipeline
+   * - Failed parsing results in unmodified log record
+   */
+  onEmit(logRecord) {
+    try {
+      if (logRecord.severityText) {
+        logRecord.setAttribute("level", logRecord.severityText.toLowerCase());
+      } else if (logRecord.severityNumber !== void 0) {
+        const levelName = this.mapSeverityNumberToLevel(logRecord.severityNumber);
+        if (levelName) {
+          logRecord.setAttribute("level", levelName);
+        }
+      }
+      const body = logRecord.body;
+      if (typeof body === "string" && body.trim().startsWith("{")) {
+        let parsed = null;
+        try {
+          parsed = JSON.parse(body);
+        } catch {
+          try {
+            parsed = this.parseJavaScriptObjectNotation(body);
+          } catch {
+          }
+        }
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          const messageValue = parsed.message;
+          const { message, ...attributesObj } = parsed;
+          const flattenedAttributes = this.flattenObject(attributesObj);
+          Object.entries(flattenedAttributes).forEach(([key, value]) => {
+            if (value !== void 0 && value !== null) {
+              logRecord.setAttribute(key, value);
+            }
+          });
+          if (messageValue) {
+            logRecord.body = messageValue;
+          }
+        }
+      }
+    } catch {
+    }
+    this.wrappedProcessor.onEmit(logRecord);
+  }
+  /**
+   * Maps OpenTelemetry severity number to log level name
+   *
+   * OpenTelemetry defines severity numbers from 1-24:
+   * - 1-4: TRACE
+   * - 5-8: DEBUG
+   * - 9-12: INFO
+   * - 13-16: WARN
+   * - 17-20: ERROR
+   * - 21-24: FATAL
+   *
+   * @param severityNumber - OpenTelemetry severity number
+   * @returns Log level name (trace, debug, info, warn, error, fatal) or null
+   * @private
+   */
+  mapSeverityNumberToLevel(severityNumber) {
+    if (severityNumber >= 1 && severityNumber <= 4) return "trace";
+    if (severityNumber >= 5 && severityNumber <= 8) return "debug";
+    if (severityNumber >= 9 && severityNumber <= 12) return "info";
+    if (severityNumber >= 13 && severityNumber <= 16) return "warn";
+    if (severityNumber >= 17 && severityNumber <= 20) return "error";
+    if (severityNumber >= 21 && severityNumber <= 24) return "fatal";
+    return null;
+  }
+  /**
+   * Forces the processor to flush any pending log records
+   *
+   * Delegates to the wrapped processor's forceFlush method.
+   * Useful for ensuring logs are sent before application shutdown.
+   *
+   * @returns Promise that resolves when flush is complete
+   *
+   * @example
+   * ```typescript
+   * await processor.forceFlush();
+   * console.log("All logs have been sent");
+   * ```
+   */
+  async forceFlush() {
+    return this.wrappedProcessor.forceFlush();
+  }
+  /**
+   * Shuts down the processor and releases resources
+   *
+   * Delegates to the wrapped processor's shutdown method.
+   * Should be called when the application is terminating.
+   *
+   * @returns Promise that resolves when shutdown is complete
+   *
+   * @example
+   * ```typescript
+   * await processor.shutdown();
+   * console.log("Processor has been shut down");
+   * ```
+   */
+  async shutdown() {
+    return this.wrappedProcessor.shutdown();
+  }
+};
+__name(_JsonMessageProcessor, "JsonMessageProcessor");
+var JsonMessageProcessor = _JsonMessageProcessor;
+
+// src/framework/telemetry/new-relic/index.ts
+var _NewRelicTelemetry = class _NewRelicTelemetry {
+  /**
+   * Constructor for New Relic telemetry
+   *
+   * @description Constructor for New Relic telemetry
+   * @example
+   * ```typescript
+   * const telemetry = new NewRelicTelemetry();
+   * ```
+   */
+  constructor() {
+    this.validator = new NewRelicTelemetryValidator();
+    this.successChecker = new SuccessChecker();
+    this.resourceFactory = new ResourceFactory();
+  }
+  /**
+   * Checks if New Relic telemetry can be initialized
+   *
+   * Determines if New Relic telemetry is properly configured without actually
+   * attempting initialization. Useful for provider chain fallback logic.
+   *
+   * @param params - Runtime parameters to check
+   * @returns true if New Relic is configured and can be initialized
+   *
+   * @example
+   * ```typescript
+   * const telemetry = new NewRelicTelemetry();
+   * if (telemetry.canInitialize(params)) {
+   *   // New Relic is configured, use it
+   * } else {
+   *   // Try next provider
+   * }
+   * ```
+   */
+  canInitialize(params) {
+    return this.validator.isConfigured(params);
+  }
+  /**
+   * Get the OpenTelemetry instrumentation configuration for New Relic
+   *
+   * Builds and returns the complete instrumentation configuration including:
+   * - Service name and preset instrumentations
+   * - Custom resource attributes (environment)
+   * - OTLP exporters for traces, metrics, and logs
+   * - Success/failure detection for actions
+   *
+   * This method is called internally by `instrumentEntrypoint` to configure
+   * telemetry before wrapping the action.
+   *
+   * @returns Complete entrypoint instrumentation configuration
+   * @throws {TelemetryInputError} If required parameters are missing (service name, license key)
+   *
+   * @example
+   * ```typescript
+   * const telemetry = new NewRelicTelemetry();
+   * const config = telemetry.getConfig();
+   * // Returns configuration with exporters, instrumentations, and resource attributes
+   * ```
+   */
+  getConfig() {
+    return {
+      ...defineTelemetryConfig((params) => {
+        if (!this.validator.isConfigured(params)) {
+          throw new Error("New Relic telemetry is not configured");
+        }
+        this.validator.validateConfiguration(params);
+        const serviceName = params.NEW_RELIC_SERVICE_NAME;
+        return {
+          sdkConfig: {
+            serviceName,
+            instrumentations: getPresetInstrumentations("simple"),
+            resource: this.resourceFactory.createWithEnvironment(params),
+            ...this.getExportersConfig(params)
+          }
+        };
+      }),
+      isSuccessful: this.successChecker.execute.bind(this.successChecker)
+    };
+  }
+  /**
+   * Configure New Relic exporters for traces, metrics, and logs
+   *
+   * Creates OTLP exporters for all three signal types (traces, metrics, logs)
+   * and configures them to send data to New Relic. Log processors are wrapped
+   * with JsonMessageProcessor for better attribute extraction.
+   *
+   * @param params - Runtime parameters containing NEW_RELIC_LICENSE_KEY and optional NEW_RELIC_URL
+   * @returns Configuration object with traceExporter, metricReaders, and logRecordProcessors
+   * @private
+   */
+  getExportersConfig(params) {
+    const licenseKey = params.NEW_RELIC_LICENSE_KEY;
+    const newRelicUrl = params.NEW_RELIC_URL || "https://otlp.nr-data.net";
+    const makeExporterConfig = /* @__PURE__ */ __name((endpoint) => {
+      return {
+        url: `${newRelicUrl}/${endpoint}`,
+        headers: {
+          "api-key": licenseKey
+        }
+      };
+    }, "makeExporterConfig");
+    return {
+      traceExporter: new OTLPTraceExporterProto(makeExporterConfig("v1/traces")),
+      metricReaders: [
+        new PeriodicExportingMetricReader({
+          exporter: new OTLPMetricExporterProto(makeExporterConfig("v1/metrics"))
+        })
+      ],
+      logRecordProcessors: [
+        new JsonMessageProcessor(
+          new SimpleLogRecordProcessor(new OTLPLogExporterProto(makeExporterConfig("v1/logs")))
+        )
+      ]
+    };
+  }
+  /**
+   * Initialize telemetry instrumentation for a runtime action
+   *
+   * Wraps the provided action with OpenTelemetry instrumentation using
+   * New Relic as the backend. The instrumented action will automatically:
+   * - Create spans for the action execution
+   * - Export metrics during runtime
+   * - Forward logs to New Relic
+   * - Track success/failure status
+   *
+   * This method delegates to `instrumentEntrypoint` from `@adobe/aio-lib-telemetry`,
+   * passing the action and New Relic specific configuration.
+   *
+   * @param action - The runtime action function to instrument
+   * @returns The instrumented action function with telemetry enabled
+   * @throws {TelemetryInputError} If required configuration is missing
+   *
+   * @example
+   * ```typescript
+   * async function myAction(params: Record<string, unknown>) {
+   *   const logger = Telemetry.createLogger("my-action", params);
+   *   logger.info("Processing request");
+   *
+   *   return { statusCode: 200, body: { success: true } };
+   * }
+   *
+   * const telemetry = new NewRelicTelemetry();
+   * const instrumentedAction = telemetry.initialize(myAction);
+   *
+   * // instrumentedAction now sends traces, metrics, and logs to New Relic
+   * export const main = instrumentedAction;
+   * ```
+   */
+  initialize(action) {
+    return instrumentEntrypoint(action, this.getConfig());
+  }
+};
+__name(_NewRelicTelemetry, "NewRelicTelemetry");
+var NewRelicTelemetry = _NewRelicTelemetry;
+var new_relic_default = NewRelicTelemetry;
+
+// src/framework/telemetry/index.ts
+var _Telemetry = class _Telemetry {
+  /**
+   * Create a logger with standard configuration and automatic metadata injection.
+   *
+   * This method creates a structured logger and wraps it to automatically add
+   * contextual metadata to all log calls:
+   * - `x-adobe-commerce-request-id`: Extracted from `__ow_headers` (when present)
+   * - `action.type`: Extracted from `params.action_type` (when present)
+   *
+   * If ENABLE_TELEMETRY is true, uses OpenTelemetry logger; otherwise uses Core.Logger.
+   * The environment from params.ENVIRONMENT is set at the resource level and will
+   * automatically appear in all logs sent to New Relic if ENABLE_TELEMETRY is true.
+   *
+   * @param name - Logger name (typically action name)
+   * @param params - Runtime parameters containing LOG_LEVEL, optional ENABLE_TELEMETRY, ENVIRONMENT, action_type, and __ow_headers
+   * @returns Configured logger instance with automatic metadata injection
+   *
+   * @example Basic string message
+   * ```typescript
+   * const logger = Telemetry.createLogger("my-action", params);
+   * logger.info("Processing started");
+   * // Logs: "Processing started"
+   * ```
+   *
+   * @example JSON object message with automatic metadata
+   * ```typescript
+   * const logger = Telemetry.createLogger("my-action", {
+   *   ...params,
+   *   action_type: "webhook",
+   *   __ow_headers: { 'x-adobe-commerce-request-id': 'req-123' }
+   * });
+   * logger.info({
+   *   message: "User action completed",
+   *   user_id: "123"
+   * });
+   * // In New Relic: {
+   * //   message: "User action completed",
+   * //   user_id: "123",
+   * //   "x-adobe-commerce-request-id": "req-123",
+   * //   "action.type": "webhook",
+   * //   environment: "development",
+   * //   ...
+   * // }
+   * ```
+   */
+  static createLogger(name, params) {
+    const baseLogger = !params.ENABLE_TELEMETRY ? Core.Logger(name, {
+      level: params.LOG_LEVEL || "info"
+    }) : getLogger(name, {
+      level: params.LOG_LEVEL || "info"
+    });
+    const metadata = {};
+    const headers = params.__ow_headers;
+    const requestId = headers?.["x-adobe-commerce-request-id"];
+    if (requestId && requestId !== "") {
+      metadata["x-adobe-commerce-request-id"] = requestId;
+    }
+    const actionType = params.action_type;
+    if (actionType && actionType !== "") {
+      metadata["action.type"] = actionType;
+    }
+    if (Object.keys(metadata).length === 0) {
+      return baseLogger;
+    }
+    const wrapper = {
+      debug: /* @__PURE__ */ __name((message) => {
+        if (typeof message === "object" && message !== null) {
+          baseLogger.debug({ ...metadata, ...message });
+        } else {
+          baseLogger.debug(message);
+        }
+      }, "debug"),
+      info: /* @__PURE__ */ __name((message) => {
+        if (typeof message === "object" && message !== null) {
+          baseLogger.info({ ...metadata, ...message });
+        } else {
+          baseLogger.info(message);
+        }
+      }, "info"),
+      warn: /* @__PURE__ */ __name((message) => {
+        if (typeof message === "object" && message !== null) {
+          baseLogger.warn({ ...metadata, ...message });
+        } else {
+          baseLogger.warn(message);
+        }
+      }, "warn"),
+      error: /* @__PURE__ */ __name((message) => {
+        if (typeof message === "object" && message !== null) {
+          baseLogger.error({ ...metadata, ...message });
+        } else {
+          baseLogger.error(message);
+        }
+      }, "error")
+    };
+    return {
+      ...baseLogger,
+      ...wrapper
     };
   }
-};
-__name(_RuntimeActionResponse, "RuntimeActionResponse");
-var RuntimeActionResponse = _RuntimeActionResponse;
-var response_default = RuntimeActionResponse;
-
-// src/framework/runtime-action/parameters/index.ts
-var _Parameters = class _Parameters {
   /**
-   * Returns a log-ready string of the action input parameters.
-   * The `Authorization` header content will be replaced by '<hidden>'.
+   * Extract structured error information for logging
    *
-   * @param params action input parameters.
+   * Converts Error objects into a structured format suitable for logging
+   * and telemetry systems like New Relic.
    *
-   * @returns string
+   * @param error - Error object or unknown error value
+   * @returns Structured error object with name, message, and stack trace
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   // some operation
+   * } catch (error) {
+   *   logger.error("Operation failed", Telemetry.formatError(error));
+   * }
+   * ```
    */
-  static stringify(params) {
-    let headers = params.__ow_headers || {};
-    if (headers.authorization) {
-      headers = { ...headers, authorization: "<hidden>" };
+  static formatError(error) {
+    if (error instanceof Error) {
+      return {
+        error_name: error.name,
+        error_message: error.message,
+        error_stack: error.stack
+      };
     }
-    return JSON.stringify({ ...params, __ow_headers: headers });
+    return { error: String(error) };
   }
-};
-__name(_Parameters, "Parameters");
-var Parameters = _Parameters;
-var parameters_default = Parameters;
-
-// src/framework/runtime-action/validator/index.ts
-var _Validator = class _Validator {
   /**
-   * Returns the list of missing keys given an object and its required keys.
-   * A parameter is missing if its value is undefined or ''.
-   * A value of 0 or null is not considered as missing.
+   * Initialize telemetry for a runtime action with provider fallback chain
    *
-   * @param obj object to check.
-   * @param required list of required keys.
-   *        Each element can be multi-level deep using a '.' separator e.g. 'myRequiredObj.myRequiredKey'
+   * Attempts to initialize telemetry providers in the following order:
+   * 1. New Relic (if NEW_RELIC_TELEMETRY=true)
+   * 2. Grafana (if GRAFANA_TELEMETRY=true) - Future support
+   * 3. Original action (no telemetry)
    *
-   * @returns array
-   * @private
-   */
-  static getMissingKeys(obj, required) {
-    return required.filter((r) => {
-      const splits = r.split(".");
-      const last = splits[splits.length - 1];
-      const traverse = splits.slice(0, -1).reduce((tObj, split) => tObj[split] || {}, obj);
-      return last && (traverse[last] === void 0 || traverse[last] === "");
-    });
-  }
-  /**
-   * Returns the list of missing keys given an object and its required keys.
-   * A parameter is missing if its value is undefined or ''.
-   * A value of 0 or null is not considered as missing.
+   * Telemetry initialization is deferred to runtime when params are available.
+   * This allows proper configuration detection and graceful fallback to the
+   * next provider in the chain.
    *
-   * @param params action input parameters.
-   * @param requiredHeaders list of required input headers.
-   * @param requiredParams list of required input parameters.
-   *        Each element can be multi-level deep using a '.' separator e.g. 'myRequiredObj.myRequiredKey'.
+   * **IMPORTANT**: If a provider is explicitly enabled (e.g., NEW_RELIC_TELEMETRY=true)
+   * but has invalid configuration (missing API key, service name), a 500 error response
+   * is returned to alert you of the misconfiguration. This prevents silently running
+   * without telemetry when you expect it to be working.
    *
-   * @returns string|null if the return value is not null, then it holds an error message describing the missing inputs.
+   * Environment Configuration:
+   * Pass params.ENVIRONMENT to set the environment field in all logs.
+   * This can be set via environment variables in your action configuration.
+   *
+   * @param action - The runtime action function to instrument
+   * @returns The instrumented action ready for export
+   *
+   * @example Single provider (New Relic) - Valid configuration
+   * ```typescript
+   * // Environment:
+   * // ENABLE_TELEMETRY=true
+   * // NEW_RELIC_TELEMETRY=true
+   * // NEW_RELIC_SERVICE_NAME=my-service
+   * // NEW_RELIC_LICENSE_KEY=xxxxx
+   *
+   * export const main = Telemetry.initialize(myAction);
+   * // ✅ Uses New Relic telemetry
+   * ```
+   *
+   * @example New Relic enabled but misconfigured - Returns error response
+   * ```typescript
+   * // Environment:
+   * // ENABLE_TELEMETRY=true
+   * // NEW_RELIC_TELEMETRY=true
+   * // NEW_RELIC_SERVICE_NAME=my-service
+   * // Missing NEW_RELIC_LICENSE_KEY!
+   *
+   * export const main = Telemetry.initialize(myAction);
+   * // ❌ Returns { error: { statusCode: 500, body: { error: "Telemetry configuration error: NEW_RELIC_LICENSE_KEY is required" } } }
+   * // This is intentional - you want to know your telemetry config is broken!
+   * ```
+   *
+   * @example Multi-provider fallback
+   * ```typescript
+   * // Environment:
+   * // ENABLE_TELEMETRY=true
+   * // NEW_RELIC_TELEMETRY=false  // Skip New Relic
+   * // GRAFANA_TELEMETRY=true      // Use Grafana instead
+   *
+   * export const main = Telemetry.initialize(myAction);
+   * // ✅ Skips New Relic, tries Grafana (when implemented)
+   * ```
+   *
+   * @example No telemetry
+   * ```typescript
+   * // Environment:
+   * // ENABLE_TELEMETRY=false (or not set)
    *
+   * export const main = Telemetry.initialize(myAction);
+   * // ✅ Returns original action without instrumentation
+   * ```
    */
-  static checkMissingRequestInputs(params, requiredParams = [], requiredHeaders = []) {
-    let errorMessage = null;
-    requiredHeaders = requiredHeaders.map((h) => h.toLowerCase());
-    const normalizedHeaders = Object.keys(params.__ow_headers || {}).reduce(
-      (acc, key) => {
-        acc[key.toLowerCase()] = params.__ow_headers?.[key];
-        return acc;
-      },
-      {}
-    );
-    const missingHeaders = _Validator.getMissingKeys(normalizedHeaders, requiredHeaders);
-    if (missingHeaders.length > 0) {
-      errorMessage = `missing header(s) '${missingHeaders.join(", ")}'`;
-    }
-    const missingParams = _Validator.getMissingKeys(params, requiredParams);
-    if (missingParams.length > 0) {
-      if (errorMessage) {
-        errorMessage += " and ";
-      } else {
-        errorMessage = "";
+  static initialize(action) {
+    return async (params) => {
+      const newRelicTelemetry = new new_relic_default();
+      if (newRelicTelemetry.canInitialize(params)) {
+        try {
+          const instrumentedAction = newRelicTelemetry.initialize(action);
+          return await instrumentedAction(params);
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Telemetry initialization failed";
+          return response_default.error(
+            500 /* INTERNAL_ERROR */,
+            `Telemetry configuration error: ${errorMessage}`
+          );
+        }
       }
-      errorMessage += `missing parameter(s) '${missingParams.join(", ")}'`;
-    }
-    return errorMessage;
+      return action(params);
+    };
   }
 };
-__name(_Validator, "Validator");
-var Validator = _Validator;
-var validator_default = Validator;
+__name(_Telemetry, "Telemetry");
+var Telemetry = _Telemetry;
+var telemetry_default = Telemetry;
 
 // src/framework/runtime-action/index.ts
 var _RuntimeAction = class _RuntimeAction {
   /**
-   * @param name
-   * @param httpMethods
-   * @param requiredParams
-   * @param requiredHeaders
-   * @param action
-   * @returns {(function(*): Promise<any>)|*}
+   * Sets the action type for the next action execution
+   * This is used for logging to identify different action types
+   * (runtime-action, webhook-action, event-consumer-action, etc.)
+   *
+   * @param type - The action type identifier
+   */
+  static setActionType(type) {
+    _RuntimeAction.actionType = type;
+  }
+  /**
+   * Gets the current action type
+   * @returns The current action type identifier
+   */
+  static getActionType() {
+    return _RuntimeAction.actionType;
+  }
+  /**
+   * Creates a runtime action handler with validation, logging, and telemetry
+   *
+   * Wraps a user-defined action function with standardized runtime functionality:
+   * 1. Creates a structured logger with telemetry integration
+   * 2. Logs action start, headers, and body at debug level
+   * 3. Validates required parameters, headers, and HTTP methods
+   * 4. Executes the user action with logger and headers context
+   * 5. Logs the result and handles errors with appropriate status codes
+   * 6. Integrates with OpenTelemetry for distributed tracing
+   *
+   * @param name - Action name used for logging and telemetry spans (default: 'main')
+   * @param httpMethods - Allowed HTTP methods (GET, POST, etc.). Empty array allows all methods
+   * @param requiredParams - Required parameter names in the request body
+   * @param requiredHeaders - Required header names (case-insensitive)
+   * @param action - User-defined action function that receives:
+   *   - params: All request parameters including __ow_* runtime parameters
+   *   - ctx: Context object with logger and headers
+   * @returns Wrapped action function ready to be exported as Adobe I/O Runtime entrypoint
+   *
+   * @example With All Options
+   * ```typescript
+   * const handler = RuntimeAction.execute(
+   *   'processOrder',
+   *   [HttpMethod.POST],
+   *   ['orderId', 'customerId'],
+   *   ['authorization', 'x-api-key'],
+   *   async (params, { logger, headers }) => {
+   *     const { orderId, customerId } = params;
+   *     logger.info({ message: 'Processing order', orderId, customerId });
+   *
+   *     // Your business logic here
+   *     const result = await processOrderLogic(orderId, customerId);
+   *
+   *     return {
+   *       statusCode: 200,
+   *       body: { orderId, status: 'processed', result }
+   *     };
+   *   }
+   * );
+   * ```
+   *
+   * @example Minimal Configuration
+   * ```typescript
+   * const handler = RuntimeAction.execute('simpleAction', [], [], [], async (params, { logger }) => {
+   *   logger.info('Simple action executed');
+   *   return { statusCode: 200, body: { message: 'Success' } };
+   * });
+   * ```
    */
   static execute(name = "main", httpMethods = [], requiredParams = [], requiredHeaders = [], action = async (_params) => {
     return { statusCode: 200 /* OK */, body: {} };
   }) {
-    return async (params) => {
-      const logger = Core.Logger(name, { level: params.LOG_LEVEL || "info" });
+    const runtimeAction = /* @__PURE__ */ __name(async (params) => {
+      if (!params.action_type) {
+        params.action_type = _RuntimeAction.getActionType();
+      }
+      const logger = telemetry_default.createLogger(name, params);
       try {
-        logger.info(`Calling the ${name} action`);
-        logger.debug(parameters_default.stringify(params));
+        logger.debug({
+          message: `${name}-started`,
+          action_name: name
+        });
+        logger.debug({
+          message: `${name}-headers`,
+          headers: params.__ow_headers || {}
+        });
+        logger.debug({
+          message: `${name}-body`,
+          body: params.__ow_body || {}
+        });
         const validationError = _RuntimeAction.validateRequest(
           params,
           requiredParams,
           requiredHeaders,
           httpMethods,
-          logger
+          logger,
+          name
         );
         if (validationError) {
           return validationError;
         }
         const result = await action(params, { logger, headers: params.__ow_headers || {} });
-        logger.info(result);
+        logger.debug({
+          message: `${name}-completed`,
+          result
+        });
         return result;
       } catch (error) {
-        logger.error(error);
+        if (error instanceof Error) {
+          logger.error({
+            message: `${name}-failed`,
+            error: error.message,
+            stack: error.stack
+          });
+        } else {
+          logger.error({
+            message: `${name}-failed`,
+            error
+          });
+        }
         return response_default.error(500 /* INTERNAL_ERROR */, "server error");
       }
-    };
+    }, "runtimeAction");
+    return telemetry_default.initialize(runtimeAction);
   }
-  static validateRequest(params, requiredParams, requiredHeaders, httpMethods, logger) {
+  /**
+   * Validates incoming request against required parameters, headers, and HTTP methods
+   *
+   * This private method performs comprehensive request validation:
+   * 1. Checks for missing required parameters in the request body
+   * 2. Checks for missing required headers (case-insensitive)
+   * 3. Validates the HTTP method against allowed methods list
+   *
+   * @param params - Request parameters including __ow_* runtime parameters
+   * @param requiredParams - List of required parameter names to validate
+   * @param requiredHeaders - List of required header names to validate (case-insensitive)
+   * @param httpMethods - Allowed HTTP methods. Empty array skips HTTP method validation
+   * @param logger - Logger instance for error logging (child logger with request ID if present)
+   * @param name - Action name for logging
+   * @returns RuntimeActionResponseType with error details if validation fails, null if valid
+   *
+   * @private
+   *
+   * @example Validation Error Response
+   * ```typescript
+   * // Missing parameter returns:
+   * {
+   *   statusCode: 400,
+   *   body: { error: 'Missing required parameter: userId' }
+   * }
+   *
+   * // Invalid HTTP method returns:
+   * {
+   *   statusCode: 405,
+   *   body: { error: 'Invalid HTTP method: DELETE. Allowed methods are: GET, POST' }
+   * }
+   * ```
+   */
+  static validateRequest(params, requiredParams, requiredHeaders, httpMethods, logger, name) {
     const errorMessage = validator_default.checkMissingRequestInputs(params, requiredParams, requiredHeaders) ?? "";
     if (errorMessage) {
+      logger.error({
+        message: `${name}-validation-failed`,
+        error: errorMessage
+      });
       return response_default.error(400 /* BAD_REQUEST */, errorMessage);
     }
     const requestMethod = params.__ow_method?.toUpperCase();
     if (httpMethods.length > 0 && !httpMethods.includes(requestMethod)) {
       const errorMessage2 = `Invalid HTTP method: ${params.__ow_method}. Allowed methods are: ${httpMethods.join(", ")}`;
-      logger.error(errorMessage2);
+      logger.error({
+        message: `${name}-validation-failed`,
+        error: errorMessage2
+      });
       return response_default.error(405 /* METHOD_NOT_ALLOWED */, errorMessage2);
     }
     return null;
   }
 };
 __name(_RuntimeAction, "RuntimeAction");
+/**
+ * Private static property to store the action type for logging
+ * Can be set using setActionType() before calling execute()
+ */
+_RuntimeAction.actionType = "runtime-action";
 var RuntimeAction = _RuntimeAction;
 var runtime_action_default = RuntimeAction;
 
+// src/framework/runtime-action/parameters/index.ts
+var _Parameters = class _Parameters {
+  /**
+   * Returns a log-ready string of the action input parameters.
+   * The `Authorization` header content will be replaced by '<hidden>'.
+   *
+   * @param params action input parameters.
+   *
+   * @returns string
+   */
+  static stringify(params) {
+    let headers = params.__ow_headers || {};
+    if (headers.authorization) {
+      headers = { ...headers, authorization: "<hidden>" };
+    }
+    return JSON.stringify({ ...params, __ow_headers: headers });
+  }
+};
+__name(_Parameters, "Parameters");
+var Parameters = _Parameters;
+var parameters_default = Parameters;
+
 // src/framework/event-consumer-action/index.ts
-import { Core as Core2 } from "@adobe/aio-sdk";
 var _EventConsumerAction = class _EventConsumerAction {
   /**
-   * @param name
-   * @param requiredParams
-   * @param requiredHeaders
-   * @param action
-   * @returns {(function(*): Promise<any>)|*}
+   * Creates an event consumer action handler with telemetry integration
+   *
+   * This method wraps a user-defined action with:
+   * - Structured logging (all logs automatically include x-adobe-commerce-request-id if present)
+   * - Request validation for required parameters and headers
+   * - OpenTelemetry instrumentation
+   * - Standardized error handling
+   *
+   * @param name - Action name for logging and observability
+   * @param requiredParams - List of required parameter names to validate
+   * @param requiredHeaders - List of required header names to validate (case-insensitive)
+   * @param action - User's event consumer function that receives params and context
+   * @returns Wrapped action handler ready for OpenWhisk runtime
+   *
+   * @example
+   * ```typescript
+   * const handler = EventConsumerAction.execute(
+   *   'webhook-processor',
+   *   ['eventType', 'eventData'],
+   *   ['x-webhook-signature'],
+   *   async (params, { logger, headers }) => {
+   *     logger.info({
+   *       message: 'Processing webhook',
+   *       eventType: params.eventType
+   *     });
+   *     // Process event...
+   *     return { statusCode: 200, body: { processed: true } };
+   *   }
+   * );
+   * ```
    */
   static execute(name = "main", requiredParams = [], requiredHeaders = [], action = async (_params) => {
     return { statusCode: 200 /* OK */, body: {} };
   }) {
-    return async (params) => {
-      const logger = Core2.Logger(name, { level: params.LOG_LEVEL || "info" });
+    const eventConsumerAction = /* @__PURE__ */ __name(async (params) => {
+      params.action_type = "event-consumer-action";
+      const logger = telemetry_default.createLogger(name, params);
       try {
-        logger.info(`Calling the ${name} action`);
-        logger.debug(parameters_default.stringify(params));
+        logger.debug({
+          message: `${name}-started`,
+          action_name: name
+        });
+        logger.debug({
+          message: `${name}-headers`,
+          headers: params.__ow_headers || {}
+        });
+        logger.debug({
+          message: `${name}-parameters`,
+          parameters: params
+        });
         const errorMessage = validator_default.checkMissingRequestInputs(params, requiredParams, requiredHeaders) || "";
         if (errorMessage) {
+          logger.error({
+            message: `${name}-validation-failed`,
+            error: errorMessage
+          });
           return response_default.error(400 /* BAD_REQUEST */, errorMessage);
         }
         const result = await action(params, { logger, headers: params.__ow_headers || {} });
-        logger.info(result);
+        logger.debug({
+          message: `${name}-completed`,
+          result
+        });
         return result;
       } catch (error) {
-        logger.error(error);
+        if (error instanceof Error) {
+          logger.error({
+            error: error.message,
+            stack: error.stack
+          });
+        } else {
+          logger.error({ error });
+        }
         return response_default.error(500 /* INTERNAL_ERROR */, "server error");
       }
-    };
+    }, "eventConsumerAction");
+    return telemetry_default.initialize(eventConsumerAction);
   }
 };
 __name(_EventConsumerAction, "EventConsumerAction");
@@ -349,29 +1872,83 @@ var Openwhisk = _Openwhisk;
 var openwhisk_default = Openwhisk;
 
 // src/framework/openwhisk-action/index.ts
-import { Core as Core3 } from "@adobe/aio-sdk";
 var _OpenwhiskAction = class _OpenwhiskAction {
   /**
-   * @param name
-   * @param action
-   * @returns {(function(*): Promise<any>)|*}
+   * Creates an OpenWhisk webhook action handler with logging and telemetry
+   *
+   * Wraps a user-defined action function with standardized runtime functionality:
+   * 1. Creates a structured logger with telemetry integration
+   * 2. Logs action start with structured data
+   * 3. Logs request parameters at debug level
+   * 4. Executes the user action with logger and headers context
+   * 5. Logs the result and handles errors with appropriate status codes
+   * 6. Integrates with OpenTelemetry for distributed tracing
+   *
+   * The logger automatically includes x-adobe-commerce-request-id and action.type
+   * (if present) in all log messages.
+   *
+   * @param name - Action name used for logging and telemetry spans (default: 'main')
+   * @param action - User-defined action function that receives:
+   *   - params: All request parameters including __ow_* runtime parameters
+   *   - ctx: Context object with logger and headers
+   * @returns Wrapped action function ready to be exported as Adobe I/O Runtime entrypoint
+   *
+   * @example Complete Example
+   * ```typescript
+   * const handler = OpenwhiskAction.execute(
+   *   'processWebhook',
+   *   async (params, { logger, headers }) => {
+   *     logger.info({ message: 'Webhook received', event: params.event });
+   *
+   *     // Your webhook processing logic here
+   *     const result = await processWebhookData(params);
+   *
+   *     return {
+   *       statusCode: 200,
+   *       body: { status: 'processed', result }
+   *     };
+   *   }
+   * );
+   * ```
    */
   static execute(name = "main", action = async (_params) => {
     return { statusCode: 200 /* OK */, body: {} };
   }) {
-    return async (params) => {
-      const logger = Core3.Logger(name, { level: params.LOG_LEVEL || "info" });
+    const openwhiskAction = /* @__PURE__ */ __name(async (params) => {
+      params.action_type = "openwhisk-action";
+      const logger = telemetry_default.createLogger(name, params);
       try {
-        logger.info(`Calling the ${name} webhook action`);
-        logger.debug(parameters_default.stringify(params));
+        logger.debug({
+          message: `${name}-started`,
+          action_name: name
+        });
+        logger.debug({
+          message: `${name}-params`,
+          params
+        });
         const result = await action(params, { logger, headers: params.__ow_headers || {} });
-        logger.info(result);
+        logger.debug({
+          message: `${name}-completed`,
+          result
+        });
         return result;
       } catch (error) {
-        logger.error(error);
+        if (error instanceof Error) {
+          logger.error({
+            message: `${name}-failed`,
+            error: error.message,
+            stack: error.stack
+          });
+        } else {
+          logger.error({
+            message: `${name}-failed`,
+            error
+          });
+        }
         return response_default.error(500 /* INTERNAL_ERROR */, "server error");
       }
-    };
+    }, "openwhiskAction");
+    return telemetry_default.initialize(openwhiskAction);
   }
 };
 __name(_OpenwhiskAction, "OpenwhiskAction");
@@ -924,9 +2501,14 @@ var _WebhookAction = class _WebhookAction {
       return null;
     }, "verifySignature");
     const callback = /* @__PURE__ */ __name(async (params, ctx) => {
+      const { logger } = ctx;
       if (signatureVerification === "enabled" /* ENABLED */) {
         const verificationErrorMessage = await verifySignature(params);
         if (verificationErrorMessage) {
+          logger.error({
+            message: `${name}-signature-verification-failed`,
+            error: verificationErrorMessage
+          });
           const verificationErrorResponse = response_default2.exception(verificationErrorMessage);
           return response_default.success(JSON.stringify(verificationErrorResponse));
         }
@@ -937,12 +2519,17 @@ var _WebhookAction = class _WebhookAction {
       }
       const errorMessage = validator_default.checkMissingRequestInputs(params, requiredParams, requiredHeaders) ?? "";
       if (errorMessage) {
+        logger.error({
+          message: `${name}-validation-failed`,
+          error: errorMessage
+        });
         const errorMessageResponse = response_default2.exception(errorMessage);
         return response_default.success(JSON.stringify(errorMessageResponse));
       }
       const response = await action(params, ctx);
       return response_default.success(JSON.stringify(response));
     }, "callback");
+    runtime_action_default.setActionType("webhook-action");
     return runtime_action_default.execute(name, httpMethods, [], [], callback);
   }
 };
@@ -1145,6 +2732,9 @@ var _ImsToken = class _ImsToken {
   /**
    * Creates an instance of ImsToken
    *
+   * @deprecated Use `AdobeAuth.getToken()` directly and implement caching in your application.
+   * See class documentation for migration examples.
+   *
    * @param clientId - OAuth client ID for Adobe IMS authentication
    * @param clientSecret - OAuth client secret for Adobe IMS authentication
    * @param technicalAccountId - Technical account ID for service-to-service authentication
@@ -1171,6 +2761,10 @@ var _ImsToken = class _ImsToken {
   /**
    * Executes IMS token generation or retrieves a cached token
    *
+   * @deprecated Use `AdobeAuth.getToken()` directly and implement caching in your application.
+   * The built-in caching mechanism has reliability issues with the State API.
+   * See class documentation for migration examples.
+   *
    * This method first checks for a cached token. If a valid cached token exists,
    * it returns that. Otherwise, it generates a new token, caches it, and returns it.
    *
@@ -1253,6 +2847,14 @@ var _ImsToken = class _ImsToken {
   /**
    * Caches the IMS token in the state store with TTL
    *
+   * @deprecated This method has issues with State API reliability. Use application-level caching instead.
+   *
+   * **Known Issues:**
+   * - State API may not be available in all runtime environments
+   * - Hard-coded 10-minute buffer may not suit all use cases
+   * - Minimum 60-minute TTL is opinionated and inflexible
+   * - No retry mechanism for State API failures
+   *
    * @param result - The token result containing the token and expiration time
    * @returns A promise that resolves to true if caching succeeded, false otherwise
    * @private
@@ -1278,6 +2880,13 @@ var _ImsToken = class _ImsToken {
   /**
    * Retrieves a cached IMS token from the state store
    *
+   * @deprecated This method has issues with State API reliability. Use application-level caching instead.
+   *
+   * **Known Issues:**
+   * - State API may not be available in all runtime environments
+   * - No validation of cached token expiry
+   * - Silent failures may return null without proper error context
+   *
    * @returns A promise that resolves to the cached token string or null if not found
    * @private
    */
@@ -1303,6 +2912,14 @@ var _ImsToken = class _ImsToken {
   /**
    * Initializes and returns the state store instance
    *
+   * @deprecated This method relies on State API which has reliability issues.
+   * Use application-level caching instead.
+   *
+   * **Known Issues:**
+   * - State API initialization may fail silently
+   * - Not available outside Adobe I/O Runtime environments
+   * - Caches the state instance which may become stale
+   *
    * @returns A promise that resolves to the state instance or null if initialization fails
    * @private
    */
@@ -1500,44 +3117,26 @@ var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
   /**
    * Creates an instance of RuntimeApiGatewayService
    *
-   * @param clientId - OAuth client ID for Adobe IMS authentication
-   * @param clientSecret - OAuth client secret for Adobe IMS authentication
-   * @param technicalAccountId - Technical account ID for service-to-service authentication
-   * @param technicalAccountEmail - Technical account email for service-to-service authentication
-   * @param imsOrgId - IMS organization ID
-   * @param scopes - Array of scopes required for the token
    * @param namespace - The Adobe I/O Runtime namespace identifier
+   * @param imsOrgId - IMS organization ID
+   * @param imsToken - Bearer token string for authentication
    * @param logger - Optional logger instance for logging operations
    * @example
    * ```typescript
    * const service = new RuntimeApiGatewayService(
-   *   'client-id',
-   *   'client-secret',
-   *   'tech-account-id',
-   *   'tech@example.com',
-   *   'org-id',
-   *   ['openid', 'AdobeID'],
-   *   'my-namespace-12345',
-   *   logger // optional
+   *   'test-namespace',
+   *   'org-id@AdobeOrg',
+   *   'bearer-token-string',
+   *   logger
    * );
    * ```
    */
-  constructor(clientId, clientSecret, technicalAccountId, technicalAccountEmail, imsOrgId, scopes, namespace, logger = null) {
+  constructor(namespace, imsOrgId, imsToken, logger = null) {
     this.namespace = namespace;
     this.imsOrgId = imsOrgId;
-    this.customLogger = new custom_logger_default(logger);
-    this.imsToken = new ims_token_default(
-      clientId,
-      clientSecret,
-      technicalAccountId,
-      technicalAccountEmail,
-      imsOrgId,
-      scopes,
-      logger,
-      "runtime_api_gateway_token",
-      "runtime-api-gateway-context"
-    );
+    this.imsToken = imsToken;
     this.restClient = new rest_client_default();
+    this.customLogger = new custom_logger_default(logger);
   }
   /**
    * Builds the complete API endpoint URL
@@ -1552,21 +3151,13 @@ var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
   /**
    * Gets the authenticated headers for API requests
    *
-   * @returns A promise that resolves with the headers object including authentication
-   * @throws {Error} If token generation fails
+   * @returns Headers object including authentication
    * @private
    */
-  async getAuthenticatedHeaders() {
-    this.customLogger.debug("Generating authenticated headers for API request");
-    const token = await this.imsToken.execute();
-    if (!token) {
-      this.customLogger.error("Failed to generate IMS token for authenticated headers");
-      throw new Error("Failed to generate IMS token");
-    }
-    this.customLogger.debug("Successfully generated authenticated headers");
+  getAuthenticatedHeaders() {
     return {
       "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`,
+      Authorization: `Bearer ${this.imsToken}`,
       "x-gw-ims-org-id": this.imsOrgId
     };
   }
@@ -1590,7 +3181,7 @@ var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
     try {
       const url = this.buildEndpoint(endpoint);
       this.customLogger.info(`Performing GET request to: ${url}`);
-      const headers = { ...await this.getAuthenticatedHeaders(), ...additionalHeaders };
+      const headers = { ...this.getAuthenticatedHeaders(), ...additionalHeaders };
       this.customLogger.debug(`GET headers: ${JSON.stringify(headers)}`);
       const response = await this.restClient.get(url, headers, false);
       this.customLogger.debug(`GET response: ${JSON.stringify(response)}`);
@@ -1624,7 +3215,7 @@ var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
       const url = this.buildEndpoint(endpoint);
       this.customLogger.info(`Performing POST request to: ${url}`);
       this.customLogger.debug(`POST payload: ${JSON.stringify(payload)}`);
-      const headers = { ...await this.getAuthenticatedHeaders(), ...additionalHeaders };
+      const headers = { ...this.getAuthenticatedHeaders(), ...additionalHeaders };
       this.customLogger.debug(`POST headers: ${JSON.stringify(headers)}`);
       const response = await this.restClient.post(url, headers, payload, false);
       this.customLogger.debug(`POST response: ${JSON.stringify(response)}`);
@@ -1658,7 +3249,7 @@ var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
       const url = this.buildEndpoint(endpoint);
       this.customLogger.info(`Performing PUT request to: ${url}`);
       this.customLogger.debug(`PUT payload: ${JSON.stringify(payload)}`);
-      const headers = { ...await this.getAuthenticatedHeaders(), ...additionalHeaders };
+      const headers = { ...this.getAuthenticatedHeaders(), ...additionalHeaders };
       this.customLogger.debug(`PUT headers: ${JSON.stringify(headers)}`);
       const response = await this.restClient.put(url, headers, payload, false);
       this.customLogger.debug(`PUT response: ${JSON.stringify(response)}`);
@@ -1690,7 +3281,7 @@ var _RuntimeApiGatewayService = class _RuntimeApiGatewayService {
     try {
       const url = this.buildEndpoint(endpoint);
       this.customLogger.info(`Performing DELETE request to: ${url}`);
-      const headers = { ...await this.getAuthenticatedHeaders(), ...additionalHeaders };
+      const headers = { ...this.getAuthenticatedHeaders(), ...additionalHeaders };
       this.customLogger.debug(`DELETE headers: ${JSON.stringify(headers)}`);
       const response = await this.restClient.delete(url, headers, false);
       this.customLogger.debug(`DELETE response: ${JSON.stringify(response)}`);
@@ -1709,7 +3300,7 @@ _RuntimeApiGatewayService.BASE_URL = "https://adobeioruntime.net/apis";
 var RuntimeApiGatewayService = _RuntimeApiGatewayService;
 
 // src/integration/onboard-events/index.ts
-import { Core as Core4 } from "@adobe/aio-sdk";
+import { Core as Core2 } from "@adobe/aio-sdk";
 
 // src/io-events/types.ts
 var IoEventsGlobals = {
@@ -5022,7 +6613,7 @@ var _OnboardEvents = class _OnboardEvents {
       throw new Error("Access token is required");
     }
     const loggerName = projectName.toLowerCase().replace(/[^a-z0-9\s-_]/g, "").replace(/\s+/g, "-").replace(/_{2,}/g, "_").replace(/-{2,}/g, "-").trim().concat("-onboard-events");
-    this.logger = Core4.Logger(loggerName, { level: "debug" });
+    this.logger = Core2.Logger(loggerName, { level: "debug" });
     this.createProviders = new create_providers_default(
       consumerId,
       projectId,
@@ -5218,7 +6809,7 @@ var OnboardEvents = _OnboardEvents;
 var onboard_events_default = OnboardEvents;
 
 // src/integration/infinite-loop-breaker/index.ts
-import { Core as Core5, State as State2 } from "@adobe/aio-sdk";
+import { Core as Core3, State as State2 } from "@adobe/aio-sdk";
 import crypto2 from "crypto";
 var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
   // seconds
@@ -5236,7 +6827,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
     event
   }) {
     const logLevel = process.env.LOG_LEVEL || "info";
-    const logger = Core5.Logger("infiniteLoopBreaker", { level: logLevel });
+    const logger = Core3.Logger("infiniteLoopBreaker", { level: logLevel });
     logger.debug(`Checking for potential infinite loop for event: ${event}`);
     if (!eventTypes.includes(event)) {
       logger.debug(`Event type ${event} is not in the infinite loop event types list`);
@@ -6249,49 +7840,38 @@ var oauth1a_connection_default = Oauth1aConnection;
 // src/commerce/adobe-commerce-client/ims-connection/index.ts
 var _ImsConnection = class _ImsConnection {
   /**
-   * @param clientId
-   * @param clientSecret
-   * @param technicalAccountId
-   * @param technicalAccountEmail
-   * @param imsOrgId
-   * @param scopes
-   * @param logger
+   * Creates an instance of ImsConnection
+   *
+   * @param imsToken - Bearer token string for IMS authentication (generate using AdobeAuth)
+   * @param logger - Optional logger instance for logging operations
+   * @example
+   * ```typescript
+   * const token = await AdobeAuth.getToken(...);
+   * const connection = new ImsConnection(token, logger);
+   * ```
    */
-  constructor(clientId, clientSecret, technicalAccountId, technicalAccountEmail, imsOrgId, scopes, logger = null) {
-    this.clientId = clientId;
-    this.clientSecret = clientSecret;
-    this.technicalAccountId = technicalAccountId;
-    this.technicalAccountEmail = technicalAccountEmail;
-    this.imsOrgId = imsOrgId;
-    this.scopes = scopes;
+  constructor(imsToken, logger = null) {
+    this.imsToken = imsToken;
     this.customLogger = new custom_logger_default(logger);
   }
   /**
-   * @param commerceGot
+   * Extends the Commerce Got client with IMS authentication headers
+   *
+   * @param commerceGot - The Got instance to extend with authentication
+   * @returns Promise<any> - Extended Got instance with authentication headers
+   * @throws {Error} If token is invalid or empty
    */
   async extend(commerceGot) {
     this.customLogger.info("Using Commerce client with IMS authentication");
-    const tokenGenerator = new ims_token_default(
-      this.clientId,
-      this.clientSecret,
-      this.technicalAccountId,
-      this.technicalAccountEmail,
-      this.imsOrgId,
-      this.scopes,
-      this.customLogger.getLogger(),
-      "adobe_commerce_ims_token",
-      // Use specific cache key for commerce client
-      "adobe-commerce-client"
-      // Use adobe-commerce-client context for backward compatibility
-    );
-    const token = await tokenGenerator.execute();
-    if (token === null) {
+    if (!this.imsToken || this.imsToken.trim() === "") {
       throw new Error("Failed to generate or retrieve IMS token");
     }
-    this.customLogger.info(`IMS token being extended to header: ${token.substring(0, 10)}...`);
+    this.customLogger.info(
+      `IMS token being extended to header: ${this.imsToken.substring(0, 10)}...`
+    );
     return commerceGot.extend({
       headers: {
-        Authorization: `Bearer ${token}`
+        Authorization: `Bearer ${this.imsToken}`
       }
     });
   }
@@ -6863,6 +8443,7 @@ export {
   ims_token_default as ImsToken,
   infinite_loop_breaker_default as InfiniteLoopBreaker,
   IoEventsGlobals,
+  JsonMessageProcessor,
   oauth1a_connection_default as Oauth1aConnection,
   onboard_commerce_default as OnboardCommerce,
   onboard_events_default as OnboardEvents,
@@ -6881,6 +8462,9 @@ export {
   method_default as ShippingCarrierMethod,
   response_default3 as ShippingCarrierResponse,
   SignatureVerification,
+  SuccessChecker,
+  telemetry_default as Telemetry,
+  TelemetryInputError,
   validator_default as Validator,
   webhook_action_default as WebhookAction,
   WebhookActionOperation,