@adobe-commerce/aio-toolkit 1.0.8 → 1.0.10

package/dist/index.js

@@ -6,6 +6,9 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 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 __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -28,6 +31,612 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/framework/telemetry/helpers/input-error/index.ts
+var _TelemetryInputError, TelemetryInputError;
+var init_input_error = __esm({
+  "src/framework/telemetry/helpers/input-error/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    _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");
+    TelemetryInputError = _TelemetryInputError;
+  }
+});
+
+// src/framework/telemetry/new-relic/validator/index.ts
+var _NewRelicTelemetryValidator, NewRelicTelemetryValidator;
+var init_validator = __esm({
+  "src/framework/telemetry/new-relic/validator/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_input_error();
+    _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");
+    NewRelicTelemetryValidator = _NewRelicTelemetryValidator;
+  }
+});
+
+// src/framework/telemetry/helpers/resource-factory/index.ts
+var import_aio_lib_telemetry, import_resources, _ResourceFactory, ResourceFactory;
+var init_resource_factory = __esm({
+  "src/framework/telemetry/helpers/resource-factory/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_aio_lib_telemetry = require("@adobe/aio-lib-telemetry");
+    import_resources = require("@opentelemetry/resources");
+    _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 = (0, import_aio_lib_telemetry.getAioRuntimeResource)();
+        const customAttributes = {};
+        if (params.ENVIRONMENT) {
+          customAttributes.environment = params.ENVIRONMENT;
+        }
+        if (Object.keys(customAttributes).length === 0) {
+          return baseResource;
+        }
+        const customResource = (0, import_resources.resourceFromAttributes)(
+          customAttributes
+        );
+        return baseResource.merge(customResource);
+      }
+    };
+    __name(_ResourceFactory, "ResourceFactory");
+    ResourceFactory = _ResourceFactory;
+  }
+});
+
+// src/framework/telemetry/helpers/success-checker/index.ts
+var _SuccessChecker, SuccessChecker;
+var init_success_checker = __esm({
+  "src/framework/telemetry/helpers/success-checker/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    _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");
+    SuccessChecker = _SuccessChecker;
+  }
+});
+
+// src/framework/telemetry/helpers/json-message-processor/index.ts
+var _JsonMessageProcessor, JsonMessageProcessor;
+var init_json_message_processor = __esm({
+  "src/framework/telemetry/helpers/json-message-processor/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    _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");
+    JsonMessageProcessor = _JsonMessageProcessor;
+  }
+});
+
+// src/framework/telemetry/new-relic/index.ts
+var new_relic_exports = {};
+__export(new_relic_exports, {
+  default: () => new_relic_default
+});
+var import_aio_lib_telemetry2, import_otel, _NewRelicTelemetry, NewRelicTelemetry, new_relic_default;
+var init_new_relic = __esm({
+  "src/framework/telemetry/new-relic/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_aio_lib_telemetry2 = require("@adobe/aio-lib-telemetry");
+    init_validator();
+    init_resource_factory();
+    init_success_checker();
+    import_otel = require("@adobe/aio-lib-telemetry/otel");
+    init_json_message_processor();
+    _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 {
+          ...(0, import_aio_lib_telemetry2.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: (0, import_aio_lib_telemetry2.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 import_otel.OTLPTraceExporterProto(makeExporterConfig("v1/traces")),
+          metricReaders: [
+            new import_otel.PeriodicExportingMetricReader({
+              exporter: new import_otel.OTLPMetricExporterProto(makeExporterConfig("v1/metrics"))
+            })
+          ],
+          logRecordProcessors: [
+            new JsonMessageProcessor(
+              new import_otel.SimpleLogRecordProcessor(new import_otel.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 (0, import_aio_lib_telemetry2.instrumentEntrypoint)(action, this.getConfig());
+      }
+    };
+    __name(_NewRelicTelemetry, "NewRelicTelemetry");
+    NewRelicTelemetry = _NewRelicTelemetry;
+    new_relic_default = NewRelicTelemetry;
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -50,6 +659,7 @@ __export(index_exports, {
   ImsToken: () => ims_token_default,
   InfiniteLoopBreaker: () => infinite_loop_breaker_default,
   IoEventsGlobals: () => IoEventsGlobals,
+  JsonMessageProcessor: () => JsonMessageProcessor,
   Oauth1aConnection: () => oauth1a_connection_default,
   OnboardCommerce: () => onboard_commerce_default,
   OnboardEvents: () => onboard_events_default,
@@ -68,17 +678,28 @@ __export(index_exports, {
   ShippingCarrierMethod: () => method_default,
   ShippingCarrierResponse: () => response_default3,
   SignatureVerification: () => SignatureVerification,
+  SuccessChecker: () => SuccessChecker,
+  Telemetry: () => telemetry_default,
+  TelemetryInputError: () => TelemetryInputError,
   Validator: () => validator_default,
   WebhookAction: () => webhook_action_default,
   WebhookActionOperation: () => WebhookActionOperation,
   WebhookActionResponse: () => response_default2
 });
 module.exports = __toCommonJS(index_exports);
+init_cjs_shims();
+
+// src/framework/index.ts
+init_cjs_shims();
 
 // src/framework/runtime-action/index.ts
-var import_aio_sdk = require("@adobe/aio-sdk");
+init_cjs_shims();
+
+// src/framework/runtime-action/response/index.ts
+init_cjs_shims();
 
 // src/framework/runtime-action/types.ts
+init_cjs_shims();
 var HttpStatus = /* @__PURE__ */ ((HttpStatus2) => {
   HttpStatus2[HttpStatus2["OK"] = 200] = "OK";
   HttpStatus2[HttpStatus2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
@@ -140,29 +761,8 @@ __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>'.
-   *
-   * @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/runtime-action/validator/index.ts
+init_cjs_shims();
 var _Validator = class _Validator {
   /**
    * Returns the list of missing keys given an object and its required keys.
@@ -227,91 +827,582 @@ __name(_Validator, "Validator");
 var Validator = _Validator;
 var validator_default = Validator;
 
+// src/framework/telemetry/index.ts
+init_cjs_shims();
+var import_aio_sdk = require("@adobe/aio-sdk");
+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 (lazy-loaded); 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 logLevel = params.LOG_LEVEL || "info";
+    if (!params.ENABLE_TELEMETRY) {
+      const baseLogger = import_aio_sdk.Core.Logger(name, { level: logLevel });
+      return _Telemetry.wrapLogger(baseLogger, params);
+    }
+    let telemetryLogger = null;
+    let loadingPromise = null;
+    const fallbackLogger = import_aio_sdk.Core.Logger(name, { level: logLevel });
+    const loadTelemetryLogger = /* @__PURE__ */ __name(async () => {
+      if (telemetryLogger || loadingPromise) {
+        return;
+      }
+      loadingPromise = (async () => {
+        try {
+          const { getLogger } = await import("@adobe/aio-lib-telemetry");
+          telemetryLogger = getLogger(name, { level: logLevel });
+        } catch (error) {
+          telemetryLogger = fallbackLogger;
+        }
+      })();
+      await loadingPromise;
+    }, "loadTelemetryLogger");
+    loadTelemetryLogger().catch(() => {
+    });
+    const proxyLogger = {
+      debug: /* @__PURE__ */ __name((message) => {
+        const logger = telemetryLogger || fallbackLogger;
+        logger.debug(message);
+      }, "debug"),
+      info: /* @__PURE__ */ __name((message) => {
+        const logger = telemetryLogger || fallbackLogger;
+        logger.info(message);
+      }, "info"),
+      warn: /* @__PURE__ */ __name((message) => {
+        const logger = telemetryLogger || fallbackLogger;
+        logger.warn(message);
+      }, "warn"),
+      error: /* @__PURE__ */ __name((message) => {
+        const logger = telemetryLogger || fallbackLogger;
+        logger.error(message);
+      }, "error")
+    };
+    return _Telemetry.wrapLogger(proxyLogger, params);
+  }
+  /**
+   * Wrap a logger with automatic metadata injection
+   *
+   * @private
+   * @param baseLogger - The base logger to wrap
+   * @param params - Runtime parameters containing optional metadata
+   * @returns Wrapped logger with metadata injection
+   */
+  static wrapLogger(baseLogger, params) {
+    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
+    };
+  }
+  /**
+   * Extract structured error information for logging
+   *
+   * Converts Error objects into a structured format suitable for logging
+   * and telemetry systems like New Relic.
+   *
+   * @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 formatError(error) {
+    if (error instanceof Error) {
+      return {
+        error_name: error.name,
+        error_message: error.message,
+        error_stack: error.stack
+      };
+    }
+    return { error: String(error) };
+  }
+  /**
+   * Initialize telemetry for a runtime action with provider fallback chain
+   *
+   * 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)
+   *
+   * 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.
+   *
+   * **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.
+   *
+   * 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 initialize(action) {
+    return async (params) => {
+      if (params.ENABLE_TELEMETRY && params.NEW_RELIC_TELEMETRY) {
+        try {
+          const { default: NewRelicTelemetry2 } = await Promise.resolve().then(() => (init_new_relic(), new_relic_exports));
+          const newRelicTelemetry = new NewRelicTelemetry2();
+          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}`
+              );
+            }
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Failed to load telemetry module";
+          return response_default.error(
+            500 /* INTERNAL_ERROR */,
+            `Telemetry module error: ${errorMessage}`
+          );
+        }
+      }
+      return action(params);
+    };
+  }
+};
+__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 = import_aio_sdk.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/response/types.ts
+init_cjs_shims();
+
+// src/framework/runtime-action/parameters/index.ts
+init_cjs_shims();
+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
-var import_aio_sdk2 = require("@adobe/aio-sdk");
+init_cjs_shims();
 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 = import_aio_sdk2.Core.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");
@@ -319,6 +1410,7 @@ var EventConsumerAction = _EventConsumerAction;
 var event_consumer_action_default = EventConsumerAction;
 
 // src/framework/graphql-action/index.ts
+init_cjs_shims();
 var import_graphql = require("graphql");
 var _GraphQlAction = class _GraphQlAction {
   static execute(schema = `
@@ -396,6 +1488,7 @@ var GraphQlAction = _GraphQlAction;
 var graphql_action_default = GraphQlAction;
 
 // src/framework/openwhisk/index.ts
+init_cjs_shims();
 var import_openwhisk = __toESM(require("openwhisk"));
 var _Openwhisk = class _Openwhisk {
   /**
@@ -423,29 +1516,84 @@ var Openwhisk = _Openwhisk;
 var openwhisk_default = Openwhisk;
 
 // src/framework/openwhisk-action/index.ts
-var import_aio_sdk3 = require("@adobe/aio-sdk");
+init_cjs_shims();
 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 = import_aio_sdk3.Core.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");
@@ -453,7 +1601,8 @@ var OpenwhiskAction = _OpenwhiskAction;
 var openwhisk_action_default = OpenwhiskAction;
 
 // src/framework/repository/file-repository/index.ts
-var import_aio_sdk4 = require("@adobe/aio-sdk");
+init_cjs_shims();
+var import_aio_sdk2 = require("@adobe/aio-sdk");
 var _FileRepository = class _FileRepository {
   /**
    * Creates a new FileRepository instance
@@ -600,7 +1749,7 @@ var _FileRepository = class _FileRepository {
    */
   async getFiles() {
     if (!this.files) {
-      this.files = await import_aio_sdk4.Files.init();
+      this.files = await import_aio_sdk2.Files.init();
     }
     return this.files;
   }
@@ -609,12 +1758,17 @@ __name(_FileRepository, "FileRepository");
 var FileRepository = _FileRepository;
 var file_repository_default = FileRepository;
 
+// src/framework/repository/file-repository/types.ts
+init_cjs_shims();
+
 // src/framework/publish-event/index.ts
-var import_aio_sdk5 = require("@adobe/aio-sdk");
+init_cjs_shims();
+var import_aio_sdk3 = require("@adobe/aio-sdk");
 var import_cloudevents = require("cloudevents");
 var import_uuid = require("uuid");
 
 // src/framework/custom-logger/index.ts
+init_cjs_shims();
 var _CustomLogger = class _CustomLogger {
   /**
    * @param logger - External logger instance (can be null)
@@ -723,7 +1877,7 @@ var _PublishEvent = class _PublishEvent {
         ...subject && { subject }
       });
       this.customLogger.debug(`Constructed CloudEvent with ID: ${eventId}`);
-      const eventsClient = await import_aio_sdk5.Events.init(this.imsOrgId, this.apiKey, this.accessToken);
+      const eventsClient = await import_aio_sdk3.Events.init(this.imsOrgId, this.apiKey, this.accessToken);
       this.customLogger.debug("Adobe I/O Events client initialized successfully");
       await eventsClient.publishEvent(cloudEvent);
       const publishedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -749,7 +1903,17 @@ __name(_PublishEvent, "PublishEvent");
 var PublishEvent = _PublishEvent;
 var publish_event_default = PublishEvent;
 
+// src/framework/publish-event/types.ts
+init_cjs_shims();
+
+// src/framework/webhook-action/index.ts
+init_cjs_shims();
+
+// src/framework/webhook-action/response/index.ts
+init_cjs_shims();
+
 // src/framework/webhook-action/response/types.ts
+init_cjs_shims();
 var WebhookActionOperation = /* @__PURE__ */ ((WebhookActionOperation2) => {
   WebhookActionOperation2["SUCCESS"] = "success";
   WebhookActionOperation2["EXCEPTION"] = "exception";
@@ -948,6 +2112,7 @@ var WebhookActionResponse = _WebhookActionResponse;
 var response_default2 = WebhookActionResponse;
 
 // src/framework/webhook-action/types.ts
+init_cjs_shims();
 var SignatureVerification = /* @__PURE__ */ ((SignatureVerification2) => {
   SignatureVerification2["ENABLED"] = "enabled";
   SignatureVerification2["DISABLED"] = "disabled";
@@ -998,9 +2163,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));
         }
@@ -1011,12 +2181,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);
   }
 };
@@ -1025,10 +2200,12 @@ var WebhookAction = _WebhookAction;
 var webhook_action_default = WebhookAction;
 
 // src/framework/ims-token/index.ts
-var import_aio_sdk6 = require("@adobe/aio-sdk");
+init_cjs_shims();
+var import_aio_sdk4 = require("@adobe/aio-sdk");
 
 // src/commerce/adobe-auth/index.ts
-var import_aio_lib_ims = require("@adobe/aio-lib-ims");
+init_cjs_shims();
+var aioLibIms = __toESM(require("@adobe/aio-lib-ims"));
 var _AdobeAuth = class _AdobeAuth {
   /**
    * Retrieves an authentication token from Adobe IMS
@@ -1061,9 +2238,9 @@ var _AdobeAuth = class _AdobeAuth {
       ims_org_id: imsOrgId,
       scopes
     };
-    await import_aio_lib_ims.context.setCurrent(currentContext);
-    await import_aio_lib_ims.context.set(currentContext, config);
-    return await (0, import_aio_lib_ims.getToken)();
+    await aioLibIms.context.setCurrent(currentContext);
+    await aioLibIms.context.set(currentContext, config);
+    return await aioLibIms.getToken();
   }
 };
 __name(_AdobeAuth, "AdobeAuth");
@@ -1071,6 +2248,7 @@ var AdobeAuth = _AdobeAuth;
 var adobe_auth_default = AdobeAuth;
 
 // src/integration/bearer-token/index.ts
+init_cjs_shims();
 var _BearerToken = class _BearerToken {
   /**
    * Extracts the Bearer token from HTTP request headers and returns detailed token information.
@@ -1219,6 +2397,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
@@ -1245,6 +2426,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.
    *
@@ -1327,6 +2512,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
@@ -1352,6 +2545,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
    */
@@ -1377,6 +2577,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
    */
@@ -1384,7 +2592,7 @@ var _ImsToken = class _ImsToken {
     if (this.state === void 0) {
       try {
         this.customLogger.debug("Initializing State API for token caching");
-        this.state = await import_aio_sdk6.State.init();
+        this.state = await import_aio_sdk4.State.init();
       } catch (error) {
         this.customLogger.error(`Failed to initialize State API: ${error.message}`);
         this.state = null;
@@ -1397,7 +2605,14 @@ __name(_ImsToken, "ImsToken");
 var ImsToken = _ImsToken;
 var ims_token_default = ImsToken;
 
+// src/framework/ims-token/types.ts
+init_cjs_shims();
+
+// src/framework/runtime-api-gateway-service/index.ts
+init_cjs_shims();
+
 // src/integration/rest-client/index.ts
+init_cjs_shims();
 var import_node_fetch = __toESM(require("node-fetch"));
 var _RestClient = class _RestClient {
   /**
@@ -1574,44 +2789,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
@@ -1626,21 +2823,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
     };
   }
@@ -1664,7 +2853,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)}`);
@@ -1698,7 +2887,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)}`);
@@ -1732,7 +2921,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)}`);
@@ -1764,7 +2953,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)}`);
@@ -1782,10 +2971,35 @@ __name(_RuntimeApiGatewayService, "RuntimeApiGatewayService");
 _RuntimeApiGatewayService.BASE_URL = "https://adobeioruntime.net/apis";
 var RuntimeApiGatewayService = _RuntimeApiGatewayService;
 
+// src/framework/telemetry/types.ts
+init_cjs_shims();
+
+// src/framework/index.ts
+init_input_error();
+init_success_checker();
+init_json_message_processor();
+
+// src/integration/index.ts
+init_cjs_shims();
+
 // src/integration/onboard-events/index.ts
-var import_aio_sdk7 = require("@adobe/aio-sdk");
+init_cjs_shims();
+var import_aio_sdk5 = require("@adobe/aio-sdk");
+
+// src/integration/onboard-events/create-providers/index.ts
+init_cjs_shims();
+
+// src/io-events/index.ts
+init_cjs_shims();
+
+// src/io-events/provider/index.ts
+init_cjs_shims();
+
+// src/io-events/provider/list/index.ts
+init_cjs_shims();
 
 // src/io-events/types.ts
+init_cjs_shims();
 var IoEventsGlobals = {
   BASE_URL: "https://api.adobe.io",
   STATUS_CODES: {
@@ -2022,6 +3236,7 @@ var List = _List;
 var list_default = List;
 
 // src/io-events/provider/get/index.ts
+init_cjs_shims();
 var _Get = class _Get {
   /**
    * Constructor for Get provider service
@@ -2198,6 +3413,7 @@ var Get = _Get;
 var get_default = Get;
 
 // src/io-events/provider/create/index.ts
+init_cjs_shims();
 var _Create = class _Create {
   /**
    * Constructor for Create provider service
@@ -2365,6 +3581,7 @@ var Create = _Create;
 var create_default = Create;
 
 // src/io-events/provider/delete/index.ts
+init_cjs_shims();
 var _Delete = class _Delete {
   /**
    * Creates an instance of Delete service
@@ -2691,7 +3908,11 @@ __name(_ProviderManager, "ProviderManager");
 var ProviderManager = _ProviderManager;
 var provider_default = ProviderManager;
 
+// src/io-events/event-metadata/index.ts
+init_cjs_shims();
+
 // src/io-events/event-metadata/list/index.ts
+init_cjs_shims();
 var _List2 = class _List2 {
   /**
    * Creates an instance of List service
@@ -2882,6 +4103,7 @@ __name(_List2, "List");
 var List2 = _List2;
 
 // src/io-events/event-metadata/get/index.ts
+init_cjs_shims();
 var _Get2 = class _Get2 {
   /**
    * Creates an instance of Get service
@@ -3052,6 +4274,7 @@ __name(_Get2, "Get");
 var Get2 = _Get2;
 
 // src/io-events/event-metadata/create/index.ts
+init_cjs_shims();
 var _Create2 = class _Create2 {
   /**
    * Constructor for Create event metadata service
@@ -3316,6 +4539,7 @@ var Create2 = _Create2;
 var create_default2 = Create2;
 
 // src/io-events/event-metadata/delete/index.ts
+init_cjs_shims();
 var _Delete2 = class _Delete2 {
   /**
    * Constructor for Delete event metadata service
@@ -3625,7 +4849,11 @@ __name(_EventMetadataManager, "EventMetadataManager");
 var EventMetadataManager = _EventMetadataManager;
 var event_metadata_default = EventMetadataManager;
 
+// src/io-events/registration/index.ts
+init_cjs_shims();
+
 // src/io-events/registration/create/index.ts
+init_cjs_shims();
 var _Create3 = class _Create3 {
   /**
    * Initialize the Create service
@@ -3810,6 +5038,7 @@ var Create3 = _Create3;
 var create_default3 = Create3;
 
 // src/io-events/registration/delete/index.ts
+init_cjs_shims();
 var _Delete3 = class _Delete3 {
   /**
    * Initialize the Delete service
@@ -3928,6 +5157,7 @@ var Delete3 = _Delete3;
 var delete_default2 = Delete3;
 
 // src/io-events/registration/get/index.ts
+init_cjs_shims();
 var _Get3 = class _Get3 {
   /**
    * Initialize the Get service
@@ -4047,6 +5277,7 @@ var Get3 = _Get3;
 var get_default2 = Get3;
 
 // src/io-events/registration/list/index.ts
+init_cjs_shims();
 var _List3 = class _List3 {
   /**
    * Initialize the List service
@@ -4510,6 +5741,7 @@ var CreateProviders = _CreateProviders;
 var create_providers_default = CreateProviders;
 
 // src/integration/onboard-events/create-events/index.ts
+init_cjs_shims();
 var _CreateEvents = class _CreateEvents {
   /**
    * Creates a new CreateEvents instance
@@ -4725,6 +5957,7 @@ var CreateEvents = _CreateEvents;
 var create_events_default = CreateEvents;
 
 // src/integration/onboard-events/create-registrations/index.ts
+init_cjs_shims();
 var _CreateRegistrations = class _CreateRegistrations {
   /**
    * Creates a new CreateRegistrations instance
@@ -4998,6 +6231,7 @@ var CreateRegistrations = _CreateRegistrations;
 var create_registrations_default = CreateRegistrations;
 
 // src/integration/onboard-events/input-parser/index.ts
+init_cjs_shims();
 var _InputParser = class _InputParser {
   constructor(input) {
     this.entities = {
@@ -5096,7 +6330,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 = import_aio_sdk7.Core.Logger(loggerName, { level: "debug" });
+    this.logger = import_aio_sdk5.Core.Logger(loggerName, { level: "debug" });
     this.createProviders = new create_providers_default(
       consumerId,
       projectId,
@@ -5292,7 +6526,8 @@ var OnboardEvents = _OnboardEvents;
 var onboard_events_default = OnboardEvents;
 
 // src/integration/infinite-loop-breaker/index.ts
-var import_aio_sdk8 = require("@adobe/aio-sdk");
+init_cjs_shims();
+var import_aio_sdk6 = require("@adobe/aio-sdk");
 var import_crypto3 = __toESM(require("crypto"));
 var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
   // seconds
@@ -5310,7 +6545,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
     event
   }) {
     const logLevel = process.env.LOG_LEVEL || "info";
-    const logger = import_aio_sdk8.Core.Logger("infiniteLoopBreaker", { level: logLevel });
+    const logger = import_aio_sdk6.Core.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`);
@@ -5318,7 +6553,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
     }
     const key = typeof keyFn === "function" ? keyFn() : keyFn;
     const data = typeof fingerprintFn === "function" ? fingerprintFn() : fingerprintFn;
-    const state = await import_aio_sdk8.State.init();
+    const state = await import_aio_sdk6.State.init();
     const persistedFingerPrint = await state.get(key);
     if (!persistedFingerPrint) {
       logger.debug(`No persisted fingerprint found for key ${key}`);
@@ -5339,7 +6574,7 @@ var _InfiniteLoopBreaker = class _InfiniteLoopBreaker {
   static async storeFingerPrint(keyFn, fingerprintFn, ttl) {
     const key = typeof keyFn === "function" ? keyFn() : keyFn;
     const data = typeof fingerprintFn === "function" ? fingerprintFn() : fingerprintFn;
-    const state = await import_aio_sdk8.State.init();
+    const state = await import_aio_sdk6.State.init();
     await state.put(key, _InfiniteLoopBreaker.fingerPrint(data), {
       ttl: ttl !== void 0 ? ttl : _InfiniteLoopBreaker.DEFAULT_INFINITE_LOOP_BREAKER_TTL
     });
@@ -5388,7 +6623,11 @@ _InfiniteLoopBreaker.DEFAULT_INFINITE_LOOP_BREAKER_TTL = 60;
 var InfiniteLoopBreaker = _InfiniteLoopBreaker;
 var infinite_loop_breaker_default = InfiniteLoopBreaker;
 
+// src/integration/onboard-commerce/index.ts
+init_cjs_shims();
+
 // src/integration/onboard-commerce/configure-provider/index.ts
+init_cjs_shims();
 var import_aio_services_kit = require("@adobe-commerce/aio-services-kit");
 var _ConfigureProvider = class _ConfigureProvider {
   /**
@@ -5915,7 +7154,11 @@ __name(_OnboardCommerce, "OnboardCommerce");
 var OnboardCommerce = _OnboardCommerce;
 var onboard_commerce_default = OnboardCommerce;
 
+// src/commerce/index.ts
+init_cjs_shims();
+
 // src/commerce/adobe-commerce-client/index.ts
+init_cjs_shims();
 var import_got = __toESM(require("got"));
 var _AdobeCommerceClient = class _AdobeCommerceClient {
   /**
@@ -6054,8 +7297,12 @@ __name(_AdobeCommerceClient, "AdobeCommerceClient");
 var AdobeCommerceClient = _AdobeCommerceClient;
 var adobe_commerce_client_default = AdobeCommerceClient;
 
+// src/commerce/adobe-commerce-client/basic-auth-connection/index.ts
+init_cjs_shims();
+
 // src/commerce/adobe-commerce-client/basic-auth-connection/generate-basic-auth-token/index.ts
-var import_aio_sdk9 = require("@adobe/aio-sdk");
+init_cjs_shims();
+var import_aio_sdk7 = require("@adobe/aio-sdk");
 var _GenerateBasicAuthToken = class _GenerateBasicAuthToken {
   /**
    * @param baseUrl
@@ -6205,7 +7452,7 @@ var _GenerateBasicAuthToken = class _GenerateBasicAuthToken {
   async getState() {
     if (this.state === void 0) {
       try {
-        this.state = await import_aio_sdk9.State.init();
+        this.state = await import_aio_sdk7.State.init();
       } catch (error) {
         this.logger.debug("State API initialization failed, running without caching");
         this.state = null;
@@ -6256,6 +7503,7 @@ var BasicAuthConnection = _BasicAuthConnection;
 var basic_auth_connection_default = BasicAuthConnection;
 
 // src/commerce/adobe-commerce-client/oauth1a-connection/index.ts
+init_cjs_shims();
 var import_oauth_1 = __toESM(require("oauth-1.0a"));
 var crypto3 = __toESM(require("crypto"));
 var _Oauth1aConnection = class _Oauth1aConnection {
@@ -6315,51 +7563,41 @@ var Oauth1aConnection = _Oauth1aConnection;
 var oauth1a_connection_default = Oauth1aConnection;
 
 // src/commerce/adobe-commerce-client/ims-connection/index.ts
+init_cjs_shims();
 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}`
       }
     });
   }
@@ -6368,7 +7606,11 @@ __name(_ImsConnection, "ImsConnection");
 var ImsConnection = _ImsConnection;
 var ims_connection_default = ImsConnection;
 
+// src/commerce/shipping-carrier/index.ts
+init_cjs_shims();
+
 // src/commerce/shipping-carrier/method/index.ts
+init_cjs_shims();
 var _ShippingCarrierMethod = class _ShippingCarrierMethod {
   constructor(carrierCode, method) {
     this.methodData = { carrier_code: carrierCode, method, additional_data: [] };
@@ -6719,6 +7961,7 @@ var ShippingCarrier = _ShippingCarrier;
 var shipping_carrier_default = ShippingCarrier;
 
 // src/commerce/shipping-carrier/response/index.ts
+init_cjs_shims();
 var _ShippingCarrierResponse = class _ShippingCarrierResponse {
   constructor(carrier) {
     this.carrier = carrier;
@@ -6752,7 +7995,11 @@ __name(_ShippingCarrierResponse, "ShippingCarrierResponse");
 var ShippingCarrierResponse = _ShippingCarrierResponse;
 var response_default3 = ShippingCarrierResponse;
 
+// src/experience/index.ts
+init_cjs_shims();
+
 // src/experience/admin-ui-sdk/index.ts
+init_cjs_shims();
 var _AdminUiSdk = class _AdminUiSdk {
   /**
    * Creates a new AdminUiSdk instance
@@ -6932,6 +8179,7 @@ var AdminUiSdk = _AdminUiSdk;
   ImsToken,
   InfiniteLoopBreaker,
   IoEventsGlobals,
+  JsonMessageProcessor,
   Oauth1aConnection,
   OnboardCommerce,
   OnboardEvents,
@@ -6950,6 +8198,9 @@ var AdminUiSdk = _AdminUiSdk;
   ShippingCarrierMethod,
   ShippingCarrierResponse,
   SignatureVerification,
+  SuccessChecker,
+  Telemetry,
+  TelemetryInputError,
   Validator,
   WebhookAction,
   WebhookActionOperation,