@cdk8s/awscdk-resolver 0.0.561 → 0.0.563

package/node_modules/@smithy/core/dist-es/submodules/protocols/requestBuilder.js

@@ -1,4 +1,4 @@
-import { HttpRequest } from "@smithy/protocol-http";
+import { HttpRequest } from "./protocol-http/httpRequest";
 import { resolvedPath } from "./resolve-path";
 export function requestBuilder(input, context) {
     return new RequestBuilder(input, context);

package/node_modules/@smithy/core/dist-es/submodules/protocols/serde/FromStringShapeDeserializer.js

@@ -1,7 +1,5 @@
 import { NormalizedSchema } from "@smithy/core/schema";
-import { _parseEpochTimestamp, _parseRfc3339DateTimeWithOffset, _parseRfc7231DateTime, LazyJsonString, NumericValue, splitHeader, } from "@smithy/core/serde";
-import { fromBase64 } from "@smithy/util-base64";
-import { toUtf8 } from "@smithy/util-utf8";
+import { LazyJsonString, NumericValue, _parseEpochTimestamp, _parseRfc3339DateTimeWithOffset, _parseRfc7231DateTime, fromBase64, splitHeader, toUtf8, } from "@smithy/core/serde";
 import { SerdeContext } from "../SerdeContext";
 import { determineTimestampFormat } from "./determineTimestampFormat";
 export class FromStringShapeDeserializer extends SerdeContext {

package/node_modules/@smithy/core/dist-es/submodules/protocols/serde/HttpInterceptingShapeDeserializer.js

@@ -1,5 +1,5 @@
 import { NormalizedSchema } from "@smithy/core/schema";
-import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
+import { fromUtf8, toUtf8 } from "@smithy/core/serde";
 import { SerdeContext } from "../SerdeContext";
 import { FromStringShapeDeserializer } from "./FromStringShapeDeserializer";
 export class HttpInterceptingShapeDeserializer extends SerdeContext {

package/node_modules/@smithy/core/dist-es/submodules/protocols/serde/ToStringShapeSerializer.js

@@ -1,6 +1,5 @@
 import { NormalizedSchema } from "@smithy/core/schema";
-import { dateToUtcString, generateIdempotencyToken, LazyJsonString, quoteHeader } from "@smithy/core/serde";
-import { toBase64 } from "@smithy/util-base64";
+import { LazyJsonString, dateToUtcString, generateIdempotencyToken, quoteHeader, toBase64 } from "@smithy/core/serde";
 import { SerdeContext } from "../SerdeContext";
 import { determineTimestampFormat } from "./determineTimestampFormat";
 export class ToStringShapeSerializer extends SerdeContext {

package/node_modules/@smithy/core/dist-es/submodules/protocols/url-parser/parseUrl.js

@@ -0,0 +1,18 @@
+import { parseQueryString } from "../querystring-parser/parseQueryString";
+export const parseUrl = (url) => {
+    if (typeof url === "string") {
+        return parseUrl(new URL(url));
+    }
+    const { hostname, pathname, port, protocol, search } = url;
+    let query;
+    if (search) {
+        query = parseQueryString(search);
+    }
+    return {
+        hostname,
+        port: port ? parseInt(port) : undefined,
+        protocol,
+        path: pathname,
+        query,
+    };
+};

package/node_modules/@smithy/core/dist-es/submodules/retry/index.browser.js

@@ -0,0 +1,27 @@
+import { isStreamingPayload } from "./middleware-retry/isStreamingPayload/isStreamingPayload.browser";
+import { bindGetRetryPlugin, bindRetryMiddleware } from "./middleware-retry/retryMiddleware";
+const no = Symbol.for("node-only");
+export { isRetryableByTrait, isClockSkewError, isClockSkewCorrectedError, isBrowserNetworkError, isThrottlingError, isTransientError, isServerError, isNodeJsHttp2TransientError, } from "./service-error-classification/service-error-classification";
+export { AdaptiveRetryStrategy } from "./util-retry/AdaptiveRetryStrategy";
+export { ConfiguredRetryStrategy } from "./util-retry/ConfiguredRetryStrategy";
+export { DefaultRateLimiter } from "./util-retry/DefaultRateLimiter";
+export { StandardRetryStrategy } from "./util-retry/StandardRetryStrategy";
+export { RETRY_MODES, DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE } from "./util-retry/config";
+export { DEFAULT_RETRY_DELAY_BASE, MAXIMUM_RETRY_DELAY, THROTTLING_RETRY_DELAY_BASE, INITIAL_RETRY_TOKENS, RETRY_COST, TIMEOUT_RETRY_COST, NO_RETRY_INCREMENT, INVOCATION_ID_HEADER, REQUEST_HEADER, } from "./util-retry/constants";
+export { Retry } from "./util-retry/retries-2026-config";
+export { AdaptiveRetryStrategy as DeprecatedAdaptiveRetryStrategy, } from "./middleware-retry/retry-pre-sra-deprecated/AdaptiveRetryStrategy";
+export { StandardRetryStrategy as DeprecatedStandardRetryStrategy, } from "./middleware-retry/retry-pre-sra-deprecated/StandardRetryStrategy";
+export { defaultDelayDecider } from "./middleware-retry/retry-pre-sra-deprecated/delayDecider";
+export { defaultRetryDecider } from "./middleware-retry/retry-pre-sra-deprecated/retryDecider";
+export const ENV_MAX_ATTEMPTS = no;
+export const CONFIG_MAX_ATTEMPTS = no;
+export const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = no;
+export const ENV_RETRY_MODE = no;
+export const CONFIG_RETRY_MODE = no;
+export const NODE_RETRY_MODE_CONFIG_OPTIONS = no;
+export { resolveRetryConfig } from "./middleware-retry/configurations";
+export { omitRetryHeadersMiddleware, omitRetryHeadersMiddlewareOptions, getOmitRetryHeadersPlugin, } from "./middleware-retry/omitRetryHeadersMiddleware";
+export { retryMiddlewareOptions } from "./middleware-retry/retryMiddleware";
+export { getRetryAfterHint } from "./middleware-retry/parseRetryAfterHeader";
+export const retryMiddleware = bindRetryMiddleware(isStreamingPayload);
+export const getRetryPlugin = bindGetRetryPlugin(isStreamingPayload);

package/node_modules/@smithy/core/dist-es/submodules/retry/index.js

@@ -0,0 +1,20 @@
+import { isStreamingPayload } from "./middleware-retry/isStreamingPayload/isStreamingPayload";
+import { bindGetRetryPlugin, bindRetryMiddleware } from "./middleware-retry/retryMiddleware";
+export { isRetryableByTrait, isClockSkewError, isClockSkewCorrectedError, isBrowserNetworkError, isThrottlingError, isTransientError, isServerError, isNodeJsHttp2TransientError, } from "./service-error-classification/service-error-classification";
+export { AdaptiveRetryStrategy } from "./util-retry/AdaptiveRetryStrategy";
+export { ConfiguredRetryStrategy } from "./util-retry/ConfiguredRetryStrategy";
+export { DefaultRateLimiter } from "./util-retry/DefaultRateLimiter";
+export { StandardRetryStrategy } from "./util-retry/StandardRetryStrategy";
+export { RETRY_MODES, DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE } from "./util-retry/config";
+export { DEFAULT_RETRY_DELAY_BASE, MAXIMUM_RETRY_DELAY, THROTTLING_RETRY_DELAY_BASE, INITIAL_RETRY_TOKENS, RETRY_COST, TIMEOUT_RETRY_COST, NO_RETRY_INCREMENT, INVOCATION_ID_HEADER, REQUEST_HEADER, } from "./util-retry/constants";
+export { Retry } from "./util-retry/retries-2026-config";
+export { AdaptiveRetryStrategy as DeprecatedAdaptiveRetryStrategy, } from "./middleware-retry/retry-pre-sra-deprecated/AdaptiveRetryStrategy";
+export { StandardRetryStrategy as DeprecatedStandardRetryStrategy, } from "./middleware-retry/retry-pre-sra-deprecated/StandardRetryStrategy";
+export { defaultDelayDecider } from "./middleware-retry/retry-pre-sra-deprecated/delayDecider";
+export { defaultRetryDecider } from "./middleware-retry/retry-pre-sra-deprecated/retryDecider";
+export { ENV_MAX_ATTEMPTS, CONFIG_MAX_ATTEMPTS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, ENV_RETRY_MODE, CONFIG_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, resolveRetryConfig, } from "./middleware-retry/configurations";
+export { omitRetryHeadersMiddleware, omitRetryHeadersMiddlewareOptions, getOmitRetryHeadersPlugin, } from "./middleware-retry/omitRetryHeadersMiddleware";
+export { retryMiddlewareOptions } from "./middleware-retry/retryMiddleware";
+export { getRetryAfterHint } from "./middleware-retry/parseRetryAfterHeader";
+export const retryMiddleware = bindRetryMiddleware(isStreamingPayload);
+export const getRetryPlugin = bindGetRetryPlugin(isStreamingPayload);

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/configurations.js

@@ -0,0 +1,50 @@
+import { normalizeProvider } from "@smithy/core/client";
+import { AdaptiveRetryStrategy } from "../util-retry/AdaptiveRetryStrategy";
+import { StandardRetryStrategy } from "../util-retry/StandardRetryStrategy";
+import { DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE, RETRY_MODES } from "../util-retry/config";
+export const ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
+export const CONFIG_MAX_ATTEMPTS = "max_attempts";
+export const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => {
+        const value = env[ENV_MAX_ATTEMPTS];
+        if (!value)
+            return undefined;
+        const maxAttempt = parseInt(value);
+        if (Number.isNaN(maxAttempt)) {
+            throw new Error(`Environment variable ${ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`);
+        }
+        return maxAttempt;
+    },
+    configFileSelector: (profile) => {
+        const value = profile[CONFIG_MAX_ATTEMPTS];
+        if (!value)
+            return undefined;
+        const maxAttempt = parseInt(value);
+        if (Number.isNaN(maxAttempt)) {
+            throw new Error(`Shared config file entry ${CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`);
+        }
+        return maxAttempt;
+    },
+    default: DEFAULT_MAX_ATTEMPTS,
+};
+export const resolveRetryConfig = (input) => {
+    const { retryStrategy, retryMode } = input;
+    const maxAttempts = normalizeProvider(input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
+    let controller = retryStrategy
+        ? Promise.resolve(retryStrategy)
+        : undefined;
+    const getDefault = async () => (await normalizeProvider(retryMode)()) === RETRY_MODES.ADAPTIVE
+        ? new AdaptiveRetryStrategy(maxAttempts)
+        : new StandardRetryStrategy(maxAttempts);
+    return Object.assign(input, {
+        maxAttempts,
+        retryStrategy: () => (controller ??= getDefault()),
+    });
+};
+export const ENV_RETRY_MODE = "AWS_RETRY_MODE";
+export const CONFIG_RETRY_MODE = "retry_mode";
+export const NODE_RETRY_MODE_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => env[ENV_RETRY_MODE],
+    configFileSelector: (profile) => profile[CONFIG_RETRY_MODE],
+    default: DEFAULT_RETRY_MODE,
+};

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/isStreamingPayload/isStreamingPayload.js

@@ -0,0 +1,3 @@
+import { Readable } from "node:stream";
+export const isStreamingPayload = (request) => request?.body instanceof Readable ||
+    (typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream);

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/omitRetryHeadersMiddleware.js

@@ -0,0 +1,22 @@
+import { HttpRequest } from "@smithy/core/protocols";
+import { INVOCATION_ID_HEADER, REQUEST_HEADER } from "../util-retry/constants";
+export const omitRetryHeadersMiddleware = () => (next) => async (args) => {
+    const { request } = args;
+    if (HttpRequest.isInstance(request)) {
+        delete request.headers[INVOCATION_ID_HEADER];
+        delete request.headers[REQUEST_HEADER];
+    }
+    return next(args);
+};
+export const omitRetryHeadersMiddlewareOptions = {
+    name: "omitRetryHeadersMiddleware",
+    tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"],
+    relation: "before",
+    toMiddleware: "awsAuthMiddleware",
+    override: true,
+};
+export const getOmitRetryHeadersPlugin = (options) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(omitRetryHeadersMiddleware(), omitRetryHeadersMiddlewareOptions);
+    },
+});

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/parseRetryAfterHeader.js

@@ -0,0 +1,49 @@
+import { HttpResponse } from "@smithy/core/protocols";
+import { parseRfc7231DateTime } from "@smithy/core/serde";
+export function parseRetryAfterHeader(response, logger) {
+    if (!HttpResponse.isInstance(response)) {
+        return;
+    }
+    for (const header of Object.keys(response.headers)) {
+        const h = header.toLowerCase();
+        if (h === "retry-after") {
+            const retryAfter = response.headers[header];
+            let retryAfterSeconds = NaN;
+            if (retryAfter.endsWith("GMT")) {
+                try {
+                    const date = parseRfc7231DateTime(retryAfter);
+                    retryAfterSeconds = (date.getTime() - Date.now()) / 1000;
+                }
+                catch (e) {
+                    logger?.trace?.("Failed to parse retry-after header");
+                    logger?.trace?.(e);
+                }
+            }
+            else if (retryAfter.match(/ GMT, ((\d+)|(\d+\.\d+))$/)) {
+                retryAfterSeconds = Number(retryAfter.match(/ GMT, ([\d.]+)$/)?.[1]);
+            }
+            else if (retryAfter.match(/^((\d+)|(\d+\.\d+))$/)) {
+                retryAfterSeconds = Number(retryAfter);
+            }
+            else if (Date.parse(retryAfter) >= Date.now()) {
+                retryAfterSeconds = (Date.parse(retryAfter) - Date.now()) / 1000;
+            }
+            if (isNaN(retryAfterSeconds)) {
+                return;
+            }
+            return new Date(Date.now() + retryAfterSeconds * 1000);
+        }
+        else if (h === "x-amz-retry-after") {
+            const v = response.headers[header];
+            const backoffMilliseconds = Number(v);
+            if (isNaN(backoffMilliseconds)) {
+                logger?.trace?.(`Failed to parse x-amz-retry-after=${v}`);
+                return;
+            }
+            return new Date(Date.now() + backoffMilliseconds);
+        }
+    }
+}
+export function getRetryAfterHint(response, logger) {
+    return parseRetryAfterHeader(response, logger);
+}

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/retry-pre-sra-deprecated/AdaptiveRetryStrategy.js

@@ -0,0 +1,22 @@
+import { DefaultRateLimiter } from "../../util-retry/DefaultRateLimiter";
+import { RETRY_MODES } from "../../util-retry/config";
+import { StandardRetryStrategy } from "./StandardRetryStrategy";
+export class AdaptiveRetryStrategy extends StandardRetryStrategy {
+    rateLimiter;
+    constructor(maxAttemptsProvider, options) {
+        const { rateLimiter, ...superOptions } = options ?? {};
+        super(maxAttemptsProvider, superOptions);
+        this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
+        this.mode = RETRY_MODES.ADAPTIVE;
+    }
+    async retry(next, args) {
+        return super.retry(next, args, {
+            beforeRequest: async () => {
+                return this.rateLimiter.getSendToken();
+            },
+            afterRequest: (response) => {
+                this.rateLimiter.updateClientSendingRate(response);
+            },
+        });
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/retry-pre-sra-deprecated/StandardRetryStrategy.js

@@ -0,0 +1,95 @@
+import { HttpRequest, HttpResponse } from "@smithy/core/protocols";
+import { v4 } from "@smithy/core/serde";
+import { isThrottlingError } from "../../service-error-classification/service-error-classification";
+import { DEFAULT_MAX_ATTEMPTS, RETRY_MODES } from "../../util-retry/config";
+import { DEFAULT_RETRY_DELAY_BASE, INITIAL_RETRY_TOKENS, INVOCATION_ID_HEADER, REQUEST_HEADER, THROTTLING_RETRY_DELAY_BASE, } from "../../util-retry/constants";
+import { asSdkError } from "../util";
+import { getDefaultRetryQuota } from "./defaultRetryQuota";
+import { defaultDelayDecider } from "./delayDecider";
+import { defaultRetryDecider } from "./retryDecider";
+export class StandardRetryStrategy {
+    maxAttemptsProvider;
+    retryDecider;
+    delayDecider;
+    retryQuota;
+    mode = RETRY_MODES.STANDARD;
+    constructor(maxAttemptsProvider, options) {
+        this.maxAttemptsProvider = maxAttemptsProvider;
+        this.retryDecider = options?.retryDecider ?? defaultRetryDecider;
+        this.delayDecider = options?.delayDecider ?? defaultDelayDecider;
+        this.retryQuota = options?.retryQuota ?? getDefaultRetryQuota(INITIAL_RETRY_TOKENS);
+    }
+    shouldRetry(error, attempts, maxAttempts) {
+        return attempts < maxAttempts && this.retryDecider(error) && this.retryQuota.hasRetryTokens(error);
+    }
+    async getMaxAttempts() {
+        let maxAttempts;
+        try {
+            maxAttempts = await this.maxAttemptsProvider();
+        }
+        catch (error) {
+            maxAttempts = DEFAULT_MAX_ATTEMPTS;
+        }
+        return maxAttempts;
+    }
+    async retry(next, args, options) {
+        let retryTokenAmount;
+        let attempts = 0;
+        let totalDelay = 0;
+        const maxAttempts = await this.getMaxAttempts();
+        const { request } = args;
+        if (HttpRequest.isInstance(request)) {
+            request.headers[INVOCATION_ID_HEADER] = v4();
+        }
+        while (true) {
+            try {
+                if (HttpRequest.isInstance(request)) {
+                    request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
+                }
+                if (options?.beforeRequest) {
+                    await options.beforeRequest();
+                }
+                const { response, output } = await next(args);
+                if (options?.afterRequest) {
+                    options.afterRequest(response);
+                }
+                this.retryQuota.releaseRetryTokens(retryTokenAmount);
+                output.$metadata.attempts = attempts + 1;
+                output.$metadata.totalRetryDelay = totalDelay;
+                return { response, output };
+            }
+            catch (e) {
+                const err = asSdkError(e);
+                attempts++;
+                if (this.shouldRetry(err, attempts, maxAttempts)) {
+                    retryTokenAmount = this.retryQuota.retrieveRetryTokens(err);
+                    const delayFromDecider = this.delayDecider(isThrottlingError(err) ? THROTTLING_RETRY_DELAY_BASE : DEFAULT_RETRY_DELAY_BASE, attempts);
+                    const delayFromResponse = getDelayFromRetryAfterHeader(err.$response);
+                    const delay = Math.max(delayFromResponse || 0, delayFromDecider);
+                    totalDelay += delay;
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    continue;
+                }
+                if (!err.$metadata) {
+                    err.$metadata = {};
+                }
+                err.$metadata.attempts = attempts;
+                err.$metadata.totalRetryDelay = totalDelay;
+                throw err;
+            }
+        }
+    }
+}
+const getDelayFromRetryAfterHeader = (response) => {
+    if (!HttpResponse.isInstance(response))
+        return;
+    const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
+    if (!retryAfterHeaderName)
+        return;
+    const retryAfter = response.headers[retryAfterHeaderName];
+    const retryAfterSeconds = Number(retryAfter);
+    if (!Number.isNaN(retryAfterSeconds))
+        return retryAfterSeconds * 1000;
+    const retryAfterDate = new Date(retryAfter);
+    return retryAfterDate.getTime() - Date.now();
+};

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/retry-pre-sra-deprecated/defaultRetryQuota.js

@@ -0,0 +1,27 @@
+import { NO_RETRY_INCREMENT, RETRY_COST, TIMEOUT_RETRY_COST } from "../../util-retry/constants";
+export const getDefaultRetryQuota = (initialRetryTokens, options) => {
+    const MAX_CAPACITY = initialRetryTokens;
+    const noRetryIncrement = options?.noRetryIncrement ?? NO_RETRY_INCREMENT;
+    const retryCost = options?.retryCost ?? RETRY_COST;
+    const timeoutRetryCost = options?.timeoutRetryCost ?? TIMEOUT_RETRY_COST;
+    let availableCapacity = initialRetryTokens;
+    const getCapacityAmount = (error) => (error.name === "TimeoutError" ? timeoutRetryCost : retryCost);
+    const hasRetryTokens = (error) => getCapacityAmount(error) <= availableCapacity;
+    const retrieveRetryTokens = (error) => {
+        if (!hasRetryTokens(error)) {
+            throw new Error("No retry token available");
+        }
+        const capacityAmount = getCapacityAmount(error);
+        availableCapacity -= capacityAmount;
+        return capacityAmount;
+    };
+    const releaseRetryTokens = (capacityReleaseAmount) => {
+        availableCapacity += capacityReleaseAmount ?? noRetryIncrement;
+        availableCapacity = Math.min(availableCapacity, MAX_CAPACITY);
+    };
+    return Object.freeze({
+        hasRetryTokens,
+        retrieveRetryTokens,
+        releaseRetryTokens,
+    });
+};

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/retry-pre-sra-deprecated/delayDecider.js

@@ -0,0 +1,2 @@
+import { MAXIMUM_RETRY_DELAY } from "../../util-retry/constants";
+export const defaultDelayDecider = (delayBase, attempts) => Math.floor(Math.min(MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase));

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/retry-pre-sra-deprecated/retryDecider.js

@@ -0,0 +1,7 @@
+import { isClockSkewError, isRetryableByTrait, isThrottlingError, isTransientError, } from "../../service-error-classification/service-error-classification";
+export const defaultRetryDecider = (error) => {
+    if (!error) {
+        return false;
+    }
+    return isRetryableByTrait(error) || isClockSkewError(error) || isThrottlingError(error) || isTransientError(error);
+};

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/retry-pre-sra-deprecated/types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/retryMiddleware.js

@@ -0,0 +1,109 @@
+import { NoOpLogger } from "@smithy/core/client";
+import { HttpRequest } from "@smithy/core/protocols";
+import { v4 } from "@smithy/core/serde";
+import { isServerError, isThrottlingError, isTransientError, } from "../service-error-classification/service-error-classification";
+import { INVOCATION_ID_HEADER, REQUEST_HEADER } from "../util-retry/constants";
+import { parseRetryAfterHeader } from "./parseRetryAfterHeader";
+import { asSdkError } from "./util";
+export function bindRetryMiddleware(isStreamingPayload) {
+    return (options) => (next, context) => async (args) => {
+        let retryStrategy = await options.retryStrategy();
+        const maxAttempts = await options.maxAttempts();
+        if (isRetryStrategyV2(retryStrategy)) {
+            retryStrategy = retryStrategy;
+            let retryToken = await retryStrategy.acquireInitialRetryToken((context["partition_id"] ?? "") + (context.__retryLongPoll ? ":longpoll" : ""));
+            let lastError = new Error();
+            let attempts = 0;
+            let totalRetryDelay = 0;
+            const { request } = args;
+            const isRequest = HttpRequest.isInstance(request);
+            if (isRequest) {
+                request.headers[INVOCATION_ID_HEADER] = v4();
+            }
+            while (true) {
+                try {
+                    if (isRequest) {
+                        request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
+                    }
+                    const { response, output } = await next(args);
+                    retryStrategy.recordSuccess(retryToken);
+                    output.$metadata.attempts = attempts + 1;
+                    output.$metadata.totalRetryDelay = totalRetryDelay;
+                    return { response, output };
+                }
+                catch (e) {
+                    const retryErrorInfo = getRetryErrorInfo(e, options.logger);
+                    lastError = asSdkError(e);
+                    if (isRequest && isStreamingPayload(request)) {
+                        (context.logger instanceof NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request.");
+                        throw lastError;
+                    }
+                    try {
+                        retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
+                    }
+                    catch (refreshError) {
+                        if (typeof refreshError.$backoff === "number") {
+                            await cooldown(refreshError.$backoff);
+                        }
+                        if (!lastError.$metadata) {
+                            lastError.$metadata = {};
+                        }
+                        lastError.$metadata.attempts = attempts + 1;
+                        lastError.$metadata.totalRetryDelay = totalRetryDelay;
+                        throw lastError;
+                    }
+                    attempts = retryToken.getRetryCount();
+                    const delay = retryToken.getRetryDelay();
+                    totalRetryDelay += delay;
+                    await cooldown(delay);
+                }
+            }
+        }
+        else {
+            retryStrategy = retryStrategy;
+            if (retryStrategy?.mode) {
+                context.userAgent = [...(context.userAgent || []), ["cfg/retry-mode", retryStrategy.mode]];
+            }
+            return retryStrategy.retry(next, args);
+        }
+    };
+}
+const cooldown = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" &&
+    typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" &&
+    typeof retryStrategy.recordSuccess !== "undefined";
+const getRetryErrorInfo = (error, logger) => {
+    const errorInfo = {
+        error,
+        errorType: getRetryErrorType(error),
+    };
+    const retryAfterHint = parseRetryAfterHeader(error.$response, logger);
+    if (retryAfterHint) {
+        errorInfo.retryAfterHint = retryAfterHint;
+    }
+    return errorInfo;
+};
+const getRetryErrorType = (error) => {
+    if (isThrottlingError(error))
+        return "THROTTLING";
+    if (isTransientError(error))
+        return "TRANSIENT";
+    if (isServerError(error))
+        return "SERVER_ERROR";
+    return "CLIENT_ERROR";
+};
+export const retryMiddlewareOptions = {
+    name: "retryMiddleware",
+    tags: ["RETRY"],
+    step: "finalizeRequest",
+    priority: "high",
+    override: true,
+};
+export function bindGetRetryPlugin(isStreamingPayload) {
+    const retryMiddleware = bindRetryMiddleware(isStreamingPayload);
+    return (options) => ({
+        applyToStack: (clientStack) => {
+            clientStack.add(retryMiddleware(options), retryMiddlewareOptions);
+        },
+    });
+}

package/node_modules/@smithy/core/dist-es/submodules/retry/util-retry/AdaptiveRetryStrategy.js

@@ -0,0 +1,36 @@
+import { DefaultRateLimiter } from "./DefaultRateLimiter";
+import { StandardRetryStrategy } from "./StandardRetryStrategy";
+import { RETRY_MODES } from "./config";
+export class AdaptiveRetryStrategy {
+    mode = RETRY_MODES.ADAPTIVE;
+    rateLimiter;
+    standardRetryStrategy;
+    constructor(maxAttemptsProvider, options) {
+        const { rateLimiter } = options ?? {};
+        this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
+        this.standardRetryStrategy = options
+            ? new StandardRetryStrategy({
+                maxAttempts: typeof maxAttemptsProvider === "number" ? maxAttemptsProvider : 3,
+                ...options,
+            })
+            : new StandardRetryStrategy(maxAttemptsProvider);
+    }
+    async acquireInitialRetryToken(retryTokenScope) {
+        const token = await this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
+        await this.rateLimiter.getSendToken();
+        return token;
+    }
+    async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
+        this.rateLimiter.updateClientSendingRate(errorInfo);
+        const token = await this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
+        await this.rateLimiter.getSendToken();
+        return token;
+    }
+    recordSuccess(token) {
+        this.rateLimiter.updateClientSendingRate({});
+        this.standardRetryStrategy.recordSuccess(token);
+    }
+    async maxAttemptsProvider() {
+        return this.standardRetryStrategy.maxAttempts();
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/retry/util-retry/ConfiguredRetryStrategy.js

@@ -0,0 +1,19 @@
+import { StandardRetryStrategy } from "./StandardRetryStrategy";
+import { Retry } from "./retries-2026-config";
+export class ConfiguredRetryStrategy extends StandardRetryStrategy {
+    computeNextBackoffDelay;
+    constructor(maxAttempts, computeNextBackoffDelay = Retry.delay()) {
+        super(typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts);
+        if (typeof computeNextBackoffDelay === "number") {
+            this.computeNextBackoffDelay = () => computeNextBackoffDelay;
+        }
+        else {
+            this.computeNextBackoffDelay = computeNextBackoffDelay;
+        }
+    }
+    async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
+        const token = await super.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
+        token.getRetryDelay = () => this.computeNextBackoffDelay(token.getRetryCount());
+        return token;
+    }
+}