@qqbrowser/openclaw-qbot 0.10.11 → 0.10.15

package/node_modules/@smithy/core/dist-cjs/submodules/endpoints/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var config = require('@smithy/core/config');
-var protocols = require('@smithy/core/protocols');
+var transport = require('@smithy/core/transport');
 var client = require('@smithy/core/client');
 var types = require('@smithy/types');
 
@@ -125,23 +125,6 @@ const createConfigValueProvider = (configKey, canonicalEndpointParamKey, config,
     return configProvider;
 };
 
-const toEndpointV1 = (endpoint) => {
-    if (typeof endpoint === "object") {
-        if ("url" in endpoint) {
-            const v1Endpoint = protocols.parseUrl(endpoint.url);
-            if (endpoint.headers) {
-                v1Endpoint.headers = {};
-                for (const name in endpoint.headers) {
-                    v1Endpoint.headers[name.toLowerCase()] = endpoint.headers[name].join(", ");
-                }
-            }
-            return v1Endpoint;
-        }
-        return endpoint;
-    }
-    return protocols.parseUrl(endpoint);
-};
-
 function bindGetEndpointFromInstructions(getEndpointFromConfig) {
     return async (commandInput, instructionsSupplier, clientConfig, context) => {
         if (!clientConfig.isCustomEndpoint) {
@@ -153,7 +136,7 @@ function bindGetEndpointFromInstructions(getEndpointFromConfig) {
                 endpointFromConfig = await getEndpointFromConfig(clientConfig.serviceId);
             }
             if (endpointFromConfig) {
-                clientConfig.endpoint = () => Promise.resolve(toEndpointV1(endpointFromConfig));
+                clientConfig.endpoint = () => Promise.resolve(transport.toEndpointV1(endpointFromConfig));
                 clientConfig.isCustomEndpoint = true;
             }
         }
@@ -277,14 +260,14 @@ function bindResolveEndpointConfig(getEndpointFromConfig) {
     return (input) => {
         const tls = input.tls ?? true;
         const { endpoint, useDualstackEndpoint, useFipsEndpoint } = input;
-        const customEndpointProvider = endpoint != null ? async () => toEndpointV1(await client.normalizeProvider(endpoint)()) : undefined;
+        const customEndpointProvider = endpoint != null ? async () => transport.toEndpointV1(await transport.normalizeProvider(endpoint)()) : undefined;
         const isCustomEndpoint = !!endpoint;
         const resolvedConfig = Object.assign(input, {
             endpoint: customEndpointProvider,
             tls,
             isCustomEndpoint,
-            useDualstackEndpoint: client.normalizeProvider(useDualstackEndpoint ?? false),
-            useFipsEndpoint: client.normalizeProvider(useFipsEndpoint ?? false),
+            useDualstackEndpoint: transport.normalizeProvider(useDualstackEndpoint ?? false),
+            useFipsEndpoint: transport.normalizeProvider(useFipsEndpoint ?? false),
         });
         let configuredEndpointPromise = undefined;
         resolvedConfig.serviceConfiguredEndpoint = async () => {
@@ -437,20 +420,6 @@ const getAttr = (value, path) => getAttrPathList(path).reduce((acc, index) => {
 
 const isSet = (value) => value != null;
 
-const VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
-const isValidHostLabel = (value, allowSubDomains = false) => {
-    if (!allowSubDomains) {
-        return VALID_HOST_LABEL_REGEX.test(value);
-    }
-    const labels = value.split(".");
-    for (const label of labels) {
-        if (!isValidHostLabel(label)) {
-            return false;
-        }
-    }
-    return true;
-};
-
 function ite(condition, trueValue, falseValue) {
     return condition ? trueValue : falseValue;
 }
@@ -543,7 +512,7 @@ const endpointFunctions = {
     coalesce,
     getAttr,
     isSet,
-    isValidHostLabel,
+    isValidHostLabel: transport.isValidHostLabel,
     ite,
     not,
     parseURL,
@@ -873,6 +842,9 @@ const resolveEndpointConfig = bindResolveEndpointConfig(getEndpointFromConfig);
 const endpointMiddleware = bindEndpointMiddleware(getEndpointFromConfig);
 const getEndpointPlugin = bindGetEndpointPlugin(getEndpointFromConfig);
 
+exports.isValidHostLabel = transport.isValidHostLabel;
+exports.middlewareEndpointToEndpointV1 = transport.toEndpointV1;
+exports.toEndpointV1 = transport.toEndpointV1;
 exports.BinaryDecisionDiagram = BinaryDecisionDiagram;
 exports.EndpointCache = EndpointCache;
 exports.EndpointError = EndpointError;
@@ -883,10 +855,7 @@ exports.endpointMiddlewareOptions = endpointMiddlewareOptions;
 exports.getEndpointFromInstructions = getEndpointFromInstructions;
 exports.getEndpointPlugin = getEndpointPlugin;
 exports.isIpAddress = isIpAddress;
-exports.isValidHostLabel = isValidHostLabel;
-exports.middlewareEndpointToEndpointV1 = toEndpointV1;
 exports.resolveEndpoint = resolveEndpoint;
 exports.resolveEndpointConfig = resolveEndpointConfig;
 exports.resolveEndpointRequiredConfig = resolveEndpointRequiredConfig;
 exports.resolveParams = resolveParams;
-exports.toEndpointV1 = toEndpointV1;

package/node_modules/@smithy/core/dist-cjs/submodules/protocols/index.js

@@ -2,6 +2,7 @@
 
 var serde = require('@smithy/core/serde');
 var schema = require('@smithy/core/schema');
+var transport = require('@smithy/core/transport');
 var types = require('@smithy/types');
 
 const collectBody = async (streamBody = new Uint8Array(), context) => {
@@ -28,90 +29,6 @@ class SerdeContext {
     }
 }
 
-class HttpRequest {
-    method;
-    protocol;
-    hostname;
-    port;
-    path;
-    query;
-    headers;
-    username;
-    password;
-    fragment;
-    body;
-    constructor(options) {
-        this.method = options.method || "GET";
-        this.hostname = options.hostname || "localhost";
-        this.port = options.port;
-        this.query = options.query || {};
-        this.headers = options.headers || {};
-        this.body = options.body;
-        this.protocol = options.protocol
-            ? options.protocol.slice(-1) !== ":"
-                ? `${options.protocol}:`
-                : options.protocol
-            : "https:";
-        this.path = options.path ? (options.path.charAt(0) !== "/" ? `/${options.path}` : options.path) : "/";
-        this.username = options.username;
-        this.password = options.password;
-        this.fragment = options.fragment;
-    }
-    static clone(request) {
-        const cloned = new HttpRequest({
-            ...request,
-            headers: { ...request.headers },
-        });
-        if (cloned.query) {
-            cloned.query = cloneQuery(cloned.query);
-        }
-        return cloned;
-    }
-    static isInstance(request) {
-        if (!request) {
-            return false;
-        }
-        const req = request;
-        return ("method" in req &&
-            "protocol" in req &&
-            "hostname" in req &&
-            "path" in req &&
-            typeof req["query"] === "object" &&
-            typeof req["headers"] === "object");
-    }
-    clone() {
-        return HttpRequest.clone(this);
-    }
-}
-function cloneQuery(query) {
-    return Object.keys(query).reduce((carry, paramName) => {
-        const param = query[paramName];
-        return {
-            ...carry,
-            [paramName]: Array.isArray(param) ? [...param] : param,
-        };
-    }, {});
-}
-
-class HttpResponse {
-    statusCode;
-    reason;
-    headers;
-    body;
-    constructor(options) {
-        this.statusCode = options.statusCode;
-        this.reason = options.reason;
-        this.headers = options.headers || {};
-        this.body = options.body;
-    }
-    static isInstance(response) {
-        if (!response)
-            return false;
-        const resp = response;
-        return typeof resp.statusCode === "number" && typeof resp.headers === "object";
-    }
-}
-
 class HttpProtocol extends SerdeContext {
     options;
     compositeErrorRegistry;
@@ -124,10 +41,10 @@ class HttpProtocol extends SerdeContext {
         }
     }
     getRequestType() {
-        return HttpRequest;
+        return transport.HttpRequest;
     }
     getResponseType() {
-        return HttpResponse;
+        return transport.HttpResponse;
     }
     setSerdeContext(serdeContext) {
         this.serdeContext = serdeContext;
@@ -259,7 +176,7 @@ class HttpBindingProtocol extends HttpProtocol {
         const payloadMemberSchemas = [];
         let hasNonHttpBindingMember = false;
         let payload;
-        const request = new HttpRequest({
+        const request = new transport.HttpRequest({
             protocol: "",
             hostname: "",
             port: undefined,
@@ -542,7 +459,7 @@ class RpcProtocol extends HttpProtocol {
         const schema$1 = ns.getSchema();
         let payload;
         const input = _input && typeof _input === "object" ? _input : {};
-        const request = new HttpRequest({
+        const request = new transport.HttpRequest({
             protocol: "",
             hostname: "",
             port: undefined,
@@ -663,7 +580,7 @@ class RequestBuilder {
         for (const resolvePath of this.resolvePathStack) {
             resolvePath(this.path);
         }
-        return new HttpRequest({
+        return new transport.HttpRequest({
             protocol,
             hostname: this.hostname || hostname,
             port,
@@ -994,11 +911,6 @@ class Fields {
     }
 }
 
-function isValidHostname(hostname) {
-    const hostPattern = /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/;
-    return hostPattern.test(hostname);
-}
-
 const getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
     return {
         setHttpHandler(handler) {
@@ -1025,7 +937,7 @@ const CONTENT_LENGTH_HEADER = "content-length";
 function contentLengthMiddleware(bodyLengthChecker) {
     return (next) => async (args) => {
         const request = args.request;
-        if (HttpRequest.isInstance(request)) {
+        if (transport.HttpRequest.isInstance(request)) {
             const { body, headers } = request;
             if (body &&
                 Object.keys(headers)
@@ -1086,48 +998,11 @@ function buildQueryString(query) {
     return parts.join("&");
 }
 
-function parseQueryString(querystring) {
-    const query = {};
-    querystring = querystring.replace(/^\?/, "");
-    if (querystring) {
-        for (const pair of querystring.split("&")) {
-            let [key, value = null] = pair.split("=");
-            key = decodeURIComponent(key);
-            if (value) {
-                value = decodeURIComponent(value);
-            }
-            if (!(key in query)) {
-                query[key] = value;
-            }
-            else if (Array.isArray(query[key])) {
-                query[key].push(value);
-            }
-            else {
-                query[key] = [query[key], value];
-            }
-        }
-    }
-    return query;
-}
-
-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,
-    };
-};
-
+exports.HttpRequest = transport.HttpRequest;
+exports.HttpResponse = transport.HttpResponse;
+exports.isValidHostname = transport.isValidHostname;
+exports.parseQueryString = transport.parseQueryString;
+exports.parseUrl = transport.parseUrl;
 exports.Field = Field;
 exports.Fields = Fields;
 exports.FromStringShapeDeserializer = FromStringShapeDeserializer;
@@ -1135,8 +1010,6 @@ exports.HttpBindingProtocol = HttpBindingProtocol;
 exports.HttpInterceptingShapeDeserializer = HttpInterceptingShapeDeserializer;
 exports.HttpInterceptingShapeSerializer = HttpInterceptingShapeSerializer;
 exports.HttpProtocol = HttpProtocol;
-exports.HttpRequest = HttpRequest;
-exports.HttpResponse = HttpResponse;
 exports.RequestBuilder = RequestBuilder;
 exports.RpcProtocol = RpcProtocol;
 exports.SerdeContext = SerdeContext;
@@ -1151,9 +1024,6 @@ exports.escapeUriPath = escapeUriPath;
 exports.extendedEncodeURIComponent = extendedEncodeURIComponent;
 exports.getContentLengthPlugin = getContentLengthPlugin;
 exports.getHttpHandlerExtensionConfiguration = getHttpHandlerExtensionConfiguration;
-exports.isValidHostname = isValidHostname;
-exports.parseQueryString = parseQueryString;
-exports.parseUrl = parseUrl;
 exports.requestBuilder = requestBuilder;
 exports.resolveHttpHandlerRuntimeConfig = resolveHttpHandlerRuntimeConfig;
 exports.resolvedPath = resolvedPath;

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

@@ -33,7 +33,7 @@ const THROTTLING_ERROR_CODES = [
 const TRANSIENT_ERROR_CODES = ["TimeoutError", "RequestTimeout", "RequestTimeoutException"];
 const TRANSIENT_ERROR_STATUS_CODES = [500, 502, 503, 504];
 const NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT"];
-const NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND"];
+const NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND", "EAI_AGAIN"];
 
 const isRetryableByTrait = (error) => error?.$retryable !== undefined;
 const isClockSkewError = (error) => CLOCK_SKEW_ERROR_CODES.includes(error.name);
@@ -184,9 +184,6 @@ function bindRetryMiddleware(isStreamingPayload) {
                         retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
                     }
                     catch (refreshError) {
-                        if (typeof refreshError.$backoff === "number") {
-                            await cooldown(refreshError.$backoff);
-                        }
                         if (!lastError.$metadata) {
                             lastError.$metadata = {};
                         }
@@ -196,8 +193,10 @@ function bindRetryMiddleware(isStreamingPayload) {
                     }
                     attempts = retryToken.getRetryCount();
                     const delay = retryToken.getRetryDelay();
-                    totalRetryDelay += delay;
-                    await cooldown(delay);
+                    totalRetryDelay += (retryToken?.$retryLog?.acquisitionDelay ?? 0) + delay;
+                    if (delay > 0) {
+                        await cooldown(delay);
+                    }
                 }
             }
         }
@@ -398,6 +397,9 @@ class DefaultRetryToken {
     count;
     cost;
     longPoll;
+    $retryLog = {
+        acquisitionDelay: 0,
+    };
     constructor(delay, count, cost, longPoll) {
         this.delay = delay;
         this.count = count;
@@ -433,8 +435,8 @@ const refusal = {
 };
 let StandardRetryStrategy$1 = class StandardRetryStrategy {
     mode = exports.RETRY_MODES.STANDARD;
-    capacity = INITIAL_RETRY_TOKENS;
     retryBackoffStrategy;
+    capacity = INITIAL_RETRY_TOKENS;
     maxAttemptsProvider;
     baseDelay;
     constructor(arg1) {
@@ -470,14 +472,18 @@ let StandardRetryStrategy$1 = class StandardRetryStrategy {
                 retryDelay = Math.max(delayFromErrorType, Math.min(errorInfo.retryAfterHint.getTime() - Date.now(), delayFromErrorType + 5_000));
             }
             if (!shouldRetry) {
-                throw Object.assign(new Error("No retry token available"), {
-                    $backoff: Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0,
-                });
+                const longPollBackoff = Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0;
+                if (longPollBackoff > 0) {
+                    await new Promise((r) => setTimeout(r, longPollBackoff));
+                }
             }
             else {
                 const capacityCost = this.getCapacityCost(errorType);
                 this.capacity -= capacityCost;
-                return new DefaultRetryToken(retryDelay, token.getRetryCount() + 1, capacityCost, token.isLongPoll?.() ?? false);
+                const nextToken = new DefaultRetryToken(0, token.getRetryCount() + 1, capacityCost, token.isLongPoll?.() ?? false);
+                await new Promise((r) => setTimeout(r, retryDelay));
+                nextToken.$retryLog.acquisitionDelay = retryDelay;
+                return nextToken;
             }
         }
         throw new Error("No retry token available");
@@ -559,11 +565,10 @@ class ConfiguredRetryStrategy extends StandardRetryStrategy$1 {
         else {
             this.computeNextBackoffDelay = computeNextBackoffDelay;
         }
-    }
-    async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
-        const token = await super.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
-        token.getRetryDelay = () => this.computeNextBackoffDelay(token.getRetryCount());
-        return token;
+        this.retryBackoffStrategy.computeNextBackoffDelay = (completedAttempt) => {
+            const nextAttempt = completedAttempt + 1;
+            return this.computeNextBackoffDelay(nextAttempt);
+        };
     }
 }
 
@@ -710,17 +715,29 @@ class AdaptiveRetryStrategy extends StandardRetryStrategy {
     }
 }
 
-const resolveRetryConfig = (input) => {
+const resolveRetryConfig = (input, defaults) => {
     const { retryStrategy, retryMode } = input;
-    const maxAttempts = client.normalizeProvider(input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
+    const { defaultMaxAttempts = DEFAULT_MAX_ATTEMPTS, defaultBaseDelay = Retry.delay() } = defaults ?? {};
+    const maxAttemptsProvider = client.normalizeProvider(input.maxAttempts ?? defaultMaxAttempts);
     let controller = retryStrategy
         ? Promise.resolve(retryStrategy)
         : undefined;
-    const getDefault = async () => (await client.normalizeProvider(retryMode)()) === exports.RETRY_MODES.ADAPTIVE
-        ? new AdaptiveRetryStrategy$1(maxAttempts)
-        : new StandardRetryStrategy$1(maxAttempts);
+    const getDefault = async () => {
+        const maxAttempts = await maxAttemptsProvider();
+        const adaptive = (await client.normalizeProvider(retryMode)()) === exports.RETRY_MODES.ADAPTIVE;
+        if (adaptive) {
+            return new AdaptiveRetryStrategy$1(maxAttemptsProvider, {
+                maxAttempts,
+                baseDelay: defaultBaseDelay,
+            });
+        }
+        return new StandardRetryStrategy$1({
+            maxAttempts,
+            baseDelay: defaultBaseDelay,
+        });
+    };
     return Object.assign(input, {
-        maxAttempts,
+        maxAttempts: maxAttemptsProvider,
         retryStrategy: () => (controller ??= getDefault()),
     });
 };

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

@@ -35,7 +35,7 @@ const THROTTLING_ERROR_CODES = [
 const TRANSIENT_ERROR_CODES = ["TimeoutError", "RequestTimeout", "RequestTimeoutException"];
 const TRANSIENT_ERROR_STATUS_CODES = [500, 502, 503, 504];
 const NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT"];
-const NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND"];
+const NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND", "EAI_AGAIN"];
 
 const isRetryableByTrait = (error) => error?.$retryable !== undefined;
 const isClockSkewError = (error) => CLOCK_SKEW_ERROR_CODES.includes(error.name);
@@ -186,9 +186,6 @@ function bindRetryMiddleware(isStreamingPayload) {
                         retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
                     }
                     catch (refreshError) {
-                        if (typeof refreshError.$backoff === "number") {
-                            await cooldown(refreshError.$backoff);
-                        }
                         if (!lastError.$metadata) {
                             lastError.$metadata = {};
                         }
@@ -198,8 +195,10 @@ function bindRetryMiddleware(isStreamingPayload) {
                     }
                     attempts = retryToken.getRetryCount();
                     const delay = retryToken.getRetryDelay();
-                    totalRetryDelay += delay;
-                    await cooldown(delay);
+                    totalRetryDelay += (retryToken?.$retryLog?.acquisitionDelay ?? 0) + delay;
+                    if (delay > 0) {
+                        await cooldown(delay);
+                    }
                 }
             }
         }
@@ -400,6 +399,9 @@ class DefaultRetryToken {
     count;
     cost;
     longPoll;
+    $retryLog = {
+        acquisitionDelay: 0,
+    };
     constructor(delay, count, cost, longPoll) {
         this.delay = delay;
         this.count = count;
@@ -435,8 +437,8 @@ const refusal = {
 };
 let StandardRetryStrategy$1 = class StandardRetryStrategy {
     mode = exports.RETRY_MODES.STANDARD;
-    capacity = INITIAL_RETRY_TOKENS;
     retryBackoffStrategy;
+    capacity = INITIAL_RETRY_TOKENS;
     maxAttemptsProvider;
     baseDelay;
     constructor(arg1) {
@@ -472,14 +474,18 @@ let StandardRetryStrategy$1 = class StandardRetryStrategy {
                 retryDelay = Math.max(delayFromErrorType, Math.min(errorInfo.retryAfterHint.getTime() - Date.now(), delayFromErrorType + 5_000));
             }
             if (!shouldRetry) {
-                throw Object.assign(new Error("No retry token available"), {
-                    $backoff: Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0,
-                });
+                const longPollBackoff = Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0;
+                if (longPollBackoff > 0) {
+                    await new Promise((r) => setTimeout(r, longPollBackoff));
+                }
             }
             else {
                 const capacityCost = this.getCapacityCost(errorType);
                 this.capacity -= capacityCost;
-                return new DefaultRetryToken(retryDelay, token.getRetryCount() + 1, capacityCost, token.isLongPoll?.() ?? false);
+                const nextToken = new DefaultRetryToken(0, token.getRetryCount() + 1, capacityCost, token.isLongPoll?.() ?? false);
+                await new Promise((r) => setTimeout(r, retryDelay));
+                nextToken.$retryLog.acquisitionDelay = retryDelay;
+                return nextToken;
             }
         }
         throw new Error("No retry token available");
@@ -561,11 +567,10 @@ class ConfiguredRetryStrategy extends StandardRetryStrategy$1 {
         else {
             this.computeNextBackoffDelay = computeNextBackoffDelay;
         }
-    }
-    async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
-        const token = await super.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
-        token.getRetryDelay = () => this.computeNextBackoffDelay(token.getRetryCount());
-        return token;
+        this.retryBackoffStrategy.computeNextBackoffDelay = (completedAttempt) => {
+            const nextAttempt = completedAttempt + 1;
+            return this.computeNextBackoffDelay(nextAttempt);
+        };
     }
 }
 
@@ -737,17 +742,29 @@ const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
     },
     default: DEFAULT_MAX_ATTEMPTS,
 };
-const resolveRetryConfig = (input) => {
+const resolveRetryConfig = (input, defaults) => {
     const { retryStrategy, retryMode } = input;
-    const maxAttempts = client.normalizeProvider(input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
+    const { defaultMaxAttempts = DEFAULT_MAX_ATTEMPTS, defaultBaseDelay = Retry.delay() } = defaults ?? {};
+    const maxAttemptsProvider = client.normalizeProvider(input.maxAttempts ?? defaultMaxAttempts);
     let controller = retryStrategy
         ? Promise.resolve(retryStrategy)
         : undefined;
-    const getDefault = async () => (await client.normalizeProvider(retryMode)()) === exports.RETRY_MODES.ADAPTIVE
-        ? new AdaptiveRetryStrategy$1(maxAttempts)
-        : new StandardRetryStrategy$1(maxAttempts);
+    const getDefault = async () => {
+        const maxAttempts = await maxAttemptsProvider();
+        const adaptive = (await client.normalizeProvider(retryMode)()) === exports.RETRY_MODES.ADAPTIVE;
+        if (adaptive) {
+            return new AdaptiveRetryStrategy$1(maxAttemptsProvider, {
+                maxAttempts,
+                baseDelay: defaultBaseDelay,
+            });
+        }
+        return new StandardRetryStrategy$1({
+            maxAttempts,
+            baseDelay: defaultBaseDelay,
+        });
+    };
     return Object.assign(input, {
-        maxAttempts,
+        maxAttempts: maxAttemptsProvider,
         retryStrategy: () => (controller ??= getDefault()),
     });
 };

package/node_modules/@smithy/core/dist-cjs/submodules/schema/index.js

@@ -1,8 +1,6 @@
 'use strict';
 
-var client = require('@smithy/core/client');
-var protocols = require('@smithy/core/protocols');
-var endpoints = require('@smithy/core/endpoints');
+var transport = require('@smithy/core/transport');
 
 const deref = (schemaRef) => {
     if (typeof schemaRef === "function") {
@@ -21,7 +19,7 @@ const operation = (namespace, name, traits, input, output) => ({
 
 const schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
     const { response } = await next(args);
-    const { operationSchema } = client.getSmithyContext(context);
+    const { operationSchema } = transport.getSmithyContext(context);
     const [, ns, n, t, i, o] = operationSchema ?? [];
     try {
         const parsed = await config.protocol.deserializeResponse(operation(ns, n, t, i, o), {
@@ -59,11 +57,11 @@ const schemaDeserializationMiddleware = (config) => (next, context) => async (ar
                 }
             }
             try {
-                if (protocols.HttpResponse.isInstance(response)) {
-                    const { headers = {} } = response;
+                if (transport.HttpResponse.isInstance(response)) {
+                    const { headers = {}, statusCode } = response;
                     const headerEntries = Object.entries(headers);
                     error.$metadata = {
-                        httpStatusCode: response.statusCode,
+                        httpStatusCode: statusCode,
                         requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
                         extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
                         cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries),
@@ -83,10 +81,10 @@ const findHeader = (pattern, headers) => {
 };
 
 const schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
-    const { operationSchema } = client.getSmithyContext(context);
+    const { operationSchema } = transport.getSmithyContext(context);
     const [, ns, n, t, i, o] = operationSchema ?? [];
     const endpoint = context.endpointV2
-        ? async () => endpoints.toEndpointV1(context.endpointV2)
+        ? async () => transport.toEndpointV1(context.endpointV2)
         : config.endpoint;
     const request = await config.protocol.serializeRequest(operation(ns, n, t, i, o), args.input, {
         ...config,