@qqbrowser/openclaw-qbot 0.10.9 → 0.10.11

package/node_modules/@smithy/core/dist-es/submodules/endpoints/toEndpointV1.js

@@ -1,4 +1,4 @@
-import { parseUrl } from "@smithy/url-parser";
+import { parseUrl } from "@smithy/core/protocols";
 export const toEndpointV1 = (endpoint) => {
     if (typeof endpoint === "object") {
         if ("url" in endpoint) {

package/node_modules/@smithy/{util-endpoints/dist-es → core/dist-es/submodules/endpoints/util-endpoints}/utils/evaluateExpression.js

@@ -1,4 +1,4 @@
-import { EndpointError } from "../types";
+import { EndpointError, } from "../types";
 import { customEndpointFunctions } from "./customEndpointFunctions";
 import { endpointFunctions } from "./endpointFunctions";
 import { evaluateTemplate } from "./evaluateTemplate";

package/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js

@@ -1,4 +1,4 @@
-import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
+import { fromUtf8, toUtf8 } from "@smithy/core/serde";
 export class EventStreamSerde {
     marshaller;
     serializer;

package/node_modules/@smithy/{eventstream-codec/dist-es → core/dist-es/submodules/event-streams/eventstream-codec}/HeaderMarshaller.js

@@ -1,4 +1,4 @@
-import { fromHex, toHex } from "@smithy/util-hex-encoding";
+import { fromHex, toHex } from "@smithy/core/serde";
 import { Int64 } from "./Int64";
 export class HeaderMarshaller {
     toUtf8;

package/node_modules/@smithy/{eventstream-codec/dist-es → core/dist-es/submodules/event-streams/eventstream-codec}/Int64.js

@@ -1,4 +1,4 @@
-import { toHex } from "@smithy/util-hex-encoding";
+import { toHex } from "@smithy/core/serde";
 export class Int64 {
     bytes;
     constructor(bytes) {

package/node_modules/@smithy/{eventstream-serde-browser/dist-es/EventStreamMarshaller.js → core/dist-es/submodules/event-streams/eventstream-serde/EventStreamMarshaller.browser.js}

@@ -1,5 +1,5 @@
-import { EventStreamMarshaller as UniversalEventStreamMarshaller } from "@smithy/eventstream-serde-universal";
-import { iterableToReadableStream, readableStreamtoIterable } from "./utils";
+import { EventStreamMarshaller as UniversalEventStreamMarshaller } from "../eventstream-serde-universal/EventStreamMarshaller";
+import { iterableToReadableStream, readableStreamToIterable } from "./utils";
 export class EventStreamMarshaller {
     universalMarshaller;
     constructor({ utf8Encoder, utf8Decoder }) {
@@ -9,12 +9,13 @@ export class EventStreamMarshaller {
         });
     }
     deserialize(body, deserializer) {
-        const bodyIterable = isReadableStream(body) ? readableStreamtoIterable(body) : body;
+        const bodyIterable = isReadableStream(body) ? readableStreamToIterable(body) : body;
         return this.universalMarshaller.deserialize(bodyIterable, deserializer);
     }
     serialize(input, serializer) {
-        const serialziedIterable = this.universalMarshaller.serialize(input, serializer);
-        return typeof ReadableStream === "function" ? iterableToReadableStream(serialziedIterable) : serialziedIterable;
+        const serializedIterable = this.universalMarshaller.serialize(input, serializer);
+        return typeof ReadableStream === "function" ? iterableToReadableStream(serializedIterable) : serializedIterable;
     }
 }
 const isReadableStream = (body) => typeof ReadableStream === "function" && body instanceof ReadableStream;
+export const eventStreamSerdeProvider = (options) => new EventStreamMarshaller(options);

package/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde/EventStreamMarshaller.js

@@ -0,0 +1,45 @@
+import { Readable } from "node:stream";
+import { EventStreamMarshaller as UniversalEventStreamMarshaller } from "../eventstream-serde-universal/EventStreamMarshaller";
+export class EventStreamMarshaller {
+    universalMarshaller;
+    constructor({ utf8Encoder, utf8Decoder }) {
+        this.universalMarshaller = new UniversalEventStreamMarshaller({
+            utf8Decoder,
+            utf8Encoder,
+        });
+    }
+    deserialize(body, deserializer) {
+        const bodyIterable = typeof body[Symbol.asyncIterator] === "function" ? body : readableToIterable(body);
+        return this.universalMarshaller.deserialize(bodyIterable, deserializer);
+    }
+    serialize(input, serializer) {
+        return Readable.from(this.universalMarshaller.serialize(input, serializer));
+    }
+}
+export const eventStreamSerdeProvider = (options) => new EventStreamMarshaller(options);
+export async function* readableToIterable(readStream) {
+    let streamEnded = false;
+    let generationEnded = false;
+    const records = new Array();
+    readStream.on("error", (err) => {
+        if (!streamEnded) {
+            streamEnded = true;
+        }
+        if (err) {
+            throw err;
+        }
+    });
+    readStream.on("data", (data) => {
+        records.push(data);
+    });
+    readStream.on("end", () => {
+        streamEnded = true;
+    });
+    while (!generationEnded) {
+        const value = await new Promise((resolve) => setTimeout(() => resolve(records.shift()), 0));
+        if (value) {
+            yield value;
+        }
+        generationEnded = streamEnded && records.length === 0;
+    }
+}

package/node_modules/@smithy/{eventstream-serde-browser/dist-es → core/dist-es/submodules/event-streams/eventstream-serde}/utils.js

@@ -1,4 +1,4 @@
-export const readableStreamtoIterable = (readableStream) => ({
+export const readableStreamToIterable = (readableStream) => ({
     [Symbol.asyncIterator]: async function* () {
         const reader = readableStream.getReader();
         try {

package/node_modules/@smithy/{eventstream-serde-universal/dist-es → core/dist-es/submodules/event-streams/eventstream-serde-universal}/EventStreamMarshaller.js

@@ -1,4 +1,8 @@
-import { EventStreamCodec, MessageDecoderStream, MessageEncoderStream, SmithyMessageDecoderStream, SmithyMessageEncoderStream, } from "@smithy/eventstream-codec";
+import { EventStreamCodec } from "../eventstream-codec/EventStreamCodec";
+import { MessageDecoderStream } from "../eventstream-codec/MessageDecoderStream";
+import { MessageEncoderStream } from "../eventstream-codec/MessageEncoderStream";
+import { SmithyMessageDecoderStream } from "../eventstream-codec/SmithyMessageDecoderStream";
+import { SmithyMessageEncoderStream } from "../eventstream-codec/SmithyMessageEncoderStream";
 import { getChunkedStream } from "./getChunkedStream";
 import { getMessageUnmarshaller } from "./getUnmarshalledStream";
 export class EventStreamMarshaller {
@@ -23,3 +27,4 @@ export class EventStreamMarshaller {
         });
     }
 }
+export const eventStreamSerdeProvider = (options) => new EventStreamMarshaller(options);

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

@@ -0,0 +1,14 @@
+export { EventStreamCodec } from "./eventstream-codec/EventStreamCodec";
+export { HeaderMarshaller } from "./eventstream-codec/HeaderMarshaller";
+export { Int64 } from "./eventstream-codec/Int64";
+export { MessageDecoderStream } from "./eventstream-codec/MessageDecoderStream";
+export { MessageEncoderStream } from "./eventstream-codec/MessageEncoderStream";
+export { SmithyMessageDecoderStream } from "./eventstream-codec/SmithyMessageDecoderStream";
+export { SmithyMessageEncoderStream } from "./eventstream-codec/SmithyMessageEncoderStream";
+export { EventStreamMarshaller, eventStreamSerdeProvider } from "./eventstream-serde/EventStreamMarshaller.browser";
+export { readableStreamToIterable, iterableToReadableStream } from "./eventstream-serde/utils";
+export { EventStreamMarshaller as UniversalEventStreamMarshaller, eventStreamSerdeProvider as universalEventStreamSerdeProvider, } from "./eventstream-serde-universal/EventStreamMarshaller";
+export { getChunkedStream } from "./eventstream-serde-universal/getChunkedStream";
+export { getUnmarshalledStream, getMessageUnmarshaller } from "./eventstream-serde-universal/getUnmarshalledStream";
+export { resolveEventStreamSerdeConfig } from "./eventstream-serde-config-resolver/EventStreamSerdeConfig";
+export { EventStreamSerde } from "./EventStreamSerde";

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

@@ -1 +1,14 @@
-export * from "./EventStreamSerde";
+export { EventStreamCodec } from "./eventstream-codec/EventStreamCodec";
+export { HeaderMarshaller } from "./eventstream-codec/HeaderMarshaller";
+export { Int64 } from "./eventstream-codec/Int64";
+export { MessageDecoderStream } from "./eventstream-codec/MessageDecoderStream";
+export { MessageEncoderStream } from "./eventstream-codec/MessageEncoderStream";
+export { SmithyMessageDecoderStream } from "./eventstream-codec/SmithyMessageDecoderStream";
+export { SmithyMessageEncoderStream } from "./eventstream-codec/SmithyMessageEncoderStream";
+export { EventStreamMarshaller, eventStreamSerdeProvider } from "./eventstream-serde/EventStreamMarshaller";
+export { readableStreamToIterable, iterableToReadableStream } from "./eventstream-serde/utils";
+export { EventStreamMarshaller as UniversalEventStreamMarshaller, eventStreamSerdeProvider as universalEventStreamSerdeProvider, } from "./eventstream-serde-universal/EventStreamMarshaller";
+export { getChunkedStream } from "./eventstream-serde-universal/getChunkedStream";
+export { getUnmarshalledStream, getMessageUnmarshaller } from "./eventstream-serde-universal/getUnmarshalledStream";
+export { resolveEventStreamSerdeConfig } from "./eventstream-serde-config-resolver/EventStreamSerdeConfig";
+export { EventStreamSerde } from "./EventStreamSerde";

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

@@ -1,10 +1,9 @@
 import { NormalizedSchema, translateTraits } from "@smithy/core/schema";
-import { splitEvery, splitHeader } from "@smithy/core/serde";
-import { HttpRequest } from "@smithy/protocol-http";
-import { sdkStreamMixin } from "@smithy/util-stream";
+import { sdkStreamMixin, splitEvery, splitHeader } from "@smithy/core/serde";
+import { HttpProtocol } from "./HttpProtocol";
 import { collectBody } from "./collect-stream-body";
 import { extendedEncodeURIComponent } from "./extended-encode-uri-component";
-import { HttpProtocol } from "./HttpProtocol";
+import { HttpRequest } from "./protocol-http/httpRequest";
 export class HttpBindingProtocol extends HttpProtocol {
     async serializeRequest(operationSchema, _input, context) {
         const input = _input && typeof _input === "object" ? _input : {};

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

@@ -1,6 +1,7 @@
-import { NormalizedSchema, translateTraits, TypeRegistry } from "@smithy/core/schema";
-import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
+import { NormalizedSchema, TypeRegistry, translateTraits } from "@smithy/core/schema";
 import { SerdeContext } from "./SerdeContext";
+import { HttpRequest } from "./protocol-http/httpRequest";
+import { HttpResponse } from "./protocol-http/httpResponse";
 export class HttpProtocol extends SerdeContext {
     options;
     compositeErrorRegistry;

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

@@ -1,7 +1,7 @@
 import { NormalizedSchema } from "@smithy/core/schema";
-import { HttpRequest } from "@smithy/protocol-http";
-import { collectBody } from "./collect-stream-body";
 import { HttpProtocol } from "./HttpProtocol";
+import { collectBody } from "./collect-stream-body";
+import { HttpRequest } from "./protocol-http/httpRequest";
 export class RpcProtocol extends HttpProtocol {
     async serializeRequest(operationSchema, _input, context) {
         const serializer = this.serializer;

package/node_modules/@smithy/core/dist-es/submodules/protocols/collect-stream-body.js

@@ -1,4 +1,4 @@
-import { Uint8ArrayBlobAdapter } from "@smithy/util-stream";
+import { Uint8ArrayBlobAdapter } from "@smithy/core/serde";
 export const collectBody = async (streamBody = new Uint8Array(), context) => {
     if (streamBody instanceof Uint8Array) {
         return Uint8ArrayBlobAdapter.mutate(streamBody);

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

@@ -11,3 +11,15 @@ export * from "./serde/HttpInterceptingShapeSerializer";
 export * from "./serde/ToStringShapeSerializer";
 export * from "./serde/determineTimestampFormat";
 export * from "./SerdeContext";
+export { Field } from "./protocol-http/Field";
+export { Fields } from "./protocol-http/Fields";
+export { HttpRequest } from "./protocol-http/httpRequest";
+export { HttpResponse } from "./protocol-http/httpResponse";
+export { isValidHostname } from "./protocol-http/isValidHostname";
+export { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, } from "./protocol-http/extensions/httpExtensionConfiguration";
+export { contentLengthMiddleware, contentLengthMiddlewareOptions, getContentLengthPlugin, } from "./middleware-content-length/contentLengthMiddleware";
+export { escapeUri } from "./util-uri-escape/escape-uri";
+export { escapeUriPath } from "./util-uri-escape/escape-uri-path";
+export { buildQueryString } from "./querystring-builder/buildQueryString";
+export { parseQueryString } from "./querystring-parser/parseQueryString";
+export { parseUrl } from "./url-parser/parseUrl";

package/node_modules/@smithy/core/dist-es/submodules/protocols/middleware-content-length/contentLengthMiddleware.js

@@ -0,0 +1,39 @@
+import { HttpRequest } from "../protocol-http/httpRequest";
+const CONTENT_LENGTH_HEADER = "content-length";
+export function contentLengthMiddleware(bodyLengthChecker) {
+    return (next) => async (args) => {
+        const request = args.request;
+        if (HttpRequest.isInstance(request)) {
+            const { body, headers } = request;
+            if (body &&
+                Object.keys(headers)
+                    .map((str) => str.toLowerCase())
+                    .indexOf(CONTENT_LENGTH_HEADER) === -1) {
+                try {
+                    const length = bodyLengthChecker(body);
+                    request.headers = {
+                        ...request.headers,
+                        [CONTENT_LENGTH_HEADER]: String(length),
+                    };
+                }
+                catch (error) {
+                }
+            }
+        }
+        return next({
+            ...args,
+            request,
+        });
+    };
+}
+export const contentLengthMiddlewareOptions = {
+    step: "build",
+    tags: ["SET_CONTENT_LENGTH", "CONTENT_LENGTH"],
+    name: "contentLengthMiddleware",
+    override: true,
+};
+export const getContentLengthPlugin = (options) => ({
+    applyToStack: (clientStack) => {
+        clientStack.add(contentLengthMiddleware(options.bodyLengthChecker), contentLengthMiddlewareOptions);
+    },
+});

package/node_modules/@smithy/core/dist-es/submodules/protocols/querystring-builder/buildQueryString.js

@@ -0,0 +1,21 @@
+import { escapeUri } from "../util-uri-escape/escape-uri";
+export function buildQueryString(query) {
+    const parts = [];
+    for (let key of Object.keys(query).sort()) {
+        const value = query[key];
+        key = escapeUri(key);
+        if (Array.isArray(value)) {
+            for (let i = 0, iLen = value.length; i < iLen; i++) {
+                parts.push(`${key}=${escapeUri(value[i])}`);
+            }
+        }
+        else {
+            let qsEntry = key;
+            if (value || typeof value === "string") {
+                qsEntry += `=${escapeUri(value)}`;
+            }
+            parts.push(qsEntry);
+        }
+    }
+    return parts.join("&");
+}

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/{middleware-retry/dist-es → core/dist-es/submodules/retry/middleware-retry}/configurations.js

@@ -1,5 +1,7 @@
-import { normalizeProvider } from "@smithy/util-middleware";
-import { AdaptiveRetryStrategy, DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE, RETRY_MODES, StandardRetryStrategy, } from "@smithy/util-retry";
+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 = {

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

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

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

@@ -1,5 +1,5 @@
-import { HttpRequest } from "@smithy/protocol-http";
-import { INVOCATION_ID_HEADER, REQUEST_HEADER } from "@smithy/util-retry";
+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)) {

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

@@ -1,5 +1,5 @@
+import { HttpResponse } from "@smithy/core/protocols";
 import { parseRfc7231DateTime } from "@smithy/core/serde";
-import { HttpResponse } from "@smithy/protocol-http";
 export function parseRetryAfterHeader(response, logger) {
     if (!HttpResponse.isInstance(response)) {
         return;

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

@@ -1,4 +1,5 @@
-import { DefaultRateLimiter, RETRY_MODES } from "@smithy/util-retry";
+import { DefaultRateLimiter } from "../../util-retry/DefaultRateLimiter";
+import { RETRY_MODES } from "../../util-retry/config";
 import { StandardRetryStrategy } from "./StandardRetryStrategy";
 export class AdaptiveRetryStrategy extends StandardRetryStrategy {
     rateLimiter;

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

@@ -1,7 +1,8 @@
-import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
-import { isThrottlingError } from "@smithy/service-error-classification";
-import { DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_DELAY_BASE, INITIAL_RETRY_TOKENS, INVOCATION_ID_HEADER, REQUEST_HEADER, RETRY_MODES, THROTTLING_RETRY_DELAY_BASE, } from "@smithy/util-retry";
-import { v4 } from "@smithy/uuid";
+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";

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

@@ -1,4 +1,4 @@
-import { NO_RETRY_INCREMENT, RETRY_COST, TIMEOUT_RETRY_COST } from "@smithy/util-retry";
+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;

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

@@ -1,2 +1,2 @@
-import { MAXIMUM_RETRY_DELAY } from "@smithy/util-retry";
+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/{middleware-retry/dist-es → core/dist-es/submodules/retry/middleware-retry}/retry-pre-sra-deprecated/retryDecider.js

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

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/{service-error-classification/dist-es/index.js → core/dist-es/submodules/retry/service-error-classification/service-error-classification.js}

@@ -21,6 +21,7 @@ export const isThrottlingError = (error) => error.$metadata?.httpStatusCode ===
     error.$retryable?.throttling == true;
 export const isTransientError = (error, depth = 0) => isRetryableByTrait(error) ||
     isClockSkewCorrectedError(error) ||
+    (error.name === "InvalidSignatureException" && error.message?.includes("Signature expired")) ||
     TRANSIENT_ERROR_CODES.includes(error.name) ||
     NODEJS_TIMEOUT_ERROR_CODES.includes(error?.code || "") ||
     NODEJS_NETWORK_ERROR_CODES.includes(error?.code || "") ||

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

@@ -1,6 +1,6 @@
-import { RETRY_MODES } from "./config";
 import { DefaultRateLimiter } from "./DefaultRateLimiter";
 import { StandardRetryStrategy } from "./StandardRetryStrategy";
+import { RETRY_MODES } from "./config";
 export class AdaptiveRetryStrategy {
     mode = RETRY_MODES.ADAPTIVE;
     rateLimiter;
@@ -16,12 +16,15 @@ export class AdaptiveRetryStrategy {
             : new StandardRetryStrategy(maxAttemptsProvider);
     }
     async acquireInitialRetryToken(retryTokenScope) {
+        const token = await this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
         await this.rateLimiter.getSendToken();
-        return this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
+        return token;
     }
     async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
         this.rateLimiter.updateClientSendingRate(errorInfo);
-        return this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
+        const token = await this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
+        await this.rateLimiter.getSendToken();
+        return token;
     }
     recordSuccess(token) {
         this.rateLimiter.updateClientSendingRate({});