@openclaw/amazon-bedrock-provider 2026.6.5 → 2026.6.6-beta.2

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-es/submodules/retry/middleware-retry/configurations.js

@@ -2,6 +2,7 @@ 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";
+import { Retry } from "../util-retry/retries-2026-config";
 export const ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
 export const CONFIG_MAX_ATTEMPTS = "max_attempts";
 export const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
@@ -27,17 +28,29 @@ export const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
     },
     default: DEFAULT_MAX_ATTEMPTS,
 };
-export const resolveRetryConfig = (input) => {
+export const resolveRetryConfig = (input, defaults) => {
     const { retryStrategy, retryMode } = input;
-    const maxAttempts = normalizeProvider(input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
+    const { defaultMaxAttempts = DEFAULT_MAX_ATTEMPTS, defaultBaseDelay = Retry.delay() } = defaults ?? {};
+    const maxAttemptsProvider = normalizeProvider(input.maxAttempts ?? defaultMaxAttempts);
     let controller = retryStrategy
         ? Promise.resolve(retryStrategy)
         : undefined;
-    const getDefault = async () => (await normalizeProvider(retryMode)()) === RETRY_MODES.ADAPTIVE
-        ? new AdaptiveRetryStrategy(maxAttempts)
-        : new StandardRetryStrategy(maxAttempts);
+    const getDefault = async () => {
+        const maxAttempts = await maxAttemptsProvider();
+        const adaptive = (await normalizeProvider(retryMode)()) === RETRY_MODES.ADAPTIVE;
+        if (adaptive) {
+            return new AdaptiveRetryStrategy(maxAttemptsProvider, {
+                maxAttempts,
+                baseDelay: defaultBaseDelay,
+            });
+        }
+        return new StandardRetryStrategy({
+            maxAttempts,
+            baseDelay: defaultBaseDelay,
+        });
+    };
     return Object.assign(input, {
-        maxAttempts,
+        maxAttempts: maxAttemptsProvider,
         retryStrategy: () => (controller ??= getDefault()),
     });
 };

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

@@ -42,9 +42,6 @@ export 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 = {};
                         }
@@ -54,8 +51,10 @@ export 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);
+                    }
                 }
             }
         }

package/node_modules/@smithy/core/dist-es/submodules/retry/service-error-classification/constants.js

@@ -25,4 +25,4 @@ export const THROTTLING_ERROR_CODES = [
 export const TRANSIENT_ERROR_CODES = ["TimeoutError", "RequestTimeout", "RequestTimeoutException"];
 export const TRANSIENT_ERROR_STATUS_CODES = [500, 502, 503, 504];
 export const NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT"];
-export const NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND"];
+export const NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND", "EAI_AGAIN"];

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

@@ -10,10 +10,9 @@ export class ConfiguredRetryStrategy extends StandardRetryStrategy {
         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);
+        };
     }
 }

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

@@ -4,6 +4,9 @@ export class DefaultRetryToken {
     count;
     cost;
     longPoll;
+    $retryLog = {
+        acquisitionDelay: 0,
+    };
     constructor(delay, count, cost, longPoll) {
         this.delay = delay;
         this.count = count;

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

@@ -10,8 +10,8 @@ const refusal = {
 };
 export class StandardRetryStrategy {
     mode = RETRY_MODES.STANDARD;
-    capacity = INITIAL_RETRY_TOKENS;
     retryBackoffStrategy;
+    capacity = INITIAL_RETRY_TOKENS;
     maxAttemptsProvider;
     baseDelay;
     constructor(arg1) {
@@ -47,14 +47,18 @@ export 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");

package/node_modules/@smithy/core/dist-types/submodules/retry/middleware-retry/configurations.d.ts

@@ -53,7 +53,10 @@ export interface RetryResolvedConfig {
 /**
  * @internal
  */
-export declare const resolveRetryConfig: <T>(input: T & PreviouslyResolved & RetryInputConfig) => T & RetryResolvedConfig;
+export declare const resolveRetryConfig: <T>(input: T & PreviouslyResolved & RetryInputConfig, defaults?: {
+    defaultMaxAttempts?: number;
+    defaultBaseDelay?: number;
+}) => T & RetryResolvedConfig;
 /**
  * @internal
  */

package/node_modules/@smithy/core/dist-types/submodules/retry/util-retry/ConfiguredRetryStrategy.d.ts

@@ -1,4 +1,4 @@
-import type { Provider, RetryBackoffStrategy, RetryErrorInfo, RetryStrategyV2, StandardRetryToken } from "@smithy/types";
+import type { Provider, RetryBackoffStrategy, RetryStrategyV2 } from "@smithy/types";
 import { StandardRetryStrategy } from "./StandardRetryStrategy";
 /**
  * This extension of the StandardRetryStrategy allows customizing the
@@ -28,5 +28,4 @@ export declare class ConfiguredRetryStrategy extends StandardRetryStrategy imple
      * ```
      */
     constructor(maxAttempts: number | Provider<number>, computeNextBackoffDelay?: number | RetryBackoffStrategy["computeNextBackoffDelay"]);
-    refreshRetryTokenForRetry(tokenToRenew: StandardRetryToken, errorInfo: RetryErrorInfo): Promise<StandardRetryToken>;
 }

package/node_modules/@smithy/core/dist-types/submodules/retry/util-retry/DefaultRetryToken.d.ts

@@ -7,6 +7,9 @@ export declare class DefaultRetryToken implements StandardRetryToken {
     private readonly count;
     private readonly cost;
     private readonly longPoll;
+    $retryLog: {
+        acquisitionDelay: number;
+    };
     constructor(delay: number, count: number, cost: number | undefined, longPoll: boolean);
     getRetryCount(): number;
     getRetryDelay(): number;

package/node_modules/@smithy/core/dist-types/submodules/retry/util-retry/StandardRetryStrategy.d.ts

@@ -21,8 +21,8 @@ export type StandardRetryStrategyOptions = {
  */
 export declare class StandardRetryStrategy implements RetryStrategyV2 {
     readonly mode: string;
+    protected readonly retryBackoffStrategy: StandardRetryBackoffStrategy;
     private capacity;
-    private readonly retryBackoffStrategy;
     private readonly maxAttemptsProvider;
     private readonly baseDelay;
     constructor(maxAttempts: number);

package/node_modules/@smithy/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/core",
-  "version": "3.24.5",
+  "version": "3.24.6",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es:cjs'",
     "build:es:cjs": "yarn g:tsc -p tsconfig.es.json && node ../../scripts/inline core",
@@ -169,7 +169,7 @@
   "sideEffects": false,
   "dependencies": {
     "@aws-crypto/crc32": "5.2.0",
-    "@smithy/types": "^4.14.2",
+    "@smithy/types": "^4.14.3",
     "tslib": "^2.6.2"
   },
   "engines": {

package/node_modules/@smithy/credential-provider-imds/dist-cjs/index.js

@@ -1,6 +1,5 @@
 'use strict';
 
-var node_url = require('node:url');
 var config = require('@smithy/core/config');
 var node_http = require('node:http');
 var protocols = require('@smithy/core/protocols');
@@ -95,14 +94,8 @@ const requestFromEcsImds = async (timeout, options) => {
     return buffer.toString();
 };
 const CMDS_IP = "169.254.170.2";
-const GREENGRASS_HOSTS = {
-    localhost: true,
-    "127.0.0.1": true,
-};
-const GREENGRASS_PROTOCOLS = {
-    "http:": true,
-    "https:": true,
-};
+const GREENGRASS_HOSTS = new Set(["localhost", "127.0.0.1"]);
+const GREENGRASS_PROTOCOLS = new Set(["http:", "https:"]);
 const getCmdsUri = async ({ logger }) => {
     if (process.env[ENV_CMDS_RELATIVE_URI]) {
         return {
@@ -111,21 +104,29 @@ const getCmdsUri = async ({ logger }) => {
         };
     }
     if (process.env[ENV_CMDS_FULL_URI]) {
-        const parsed = node_url.parse(process.env[ENV_CMDS_FULL_URI]);
-        if (!parsed.hostname || !(parsed.hostname in GREENGRASS_HOSTS)) {
+        let parsed;
+        try {
+            parsed = new URL(process.env[ENV_CMDS_FULL_URI]);
+        }
+        catch {
+            throw new config.CredentialsProviderError(`${process.env[ENV_CMDS_FULL_URI]} is not a valid container metadata service URL`, { tryNextLink: false, logger });
+        }
+        if (!parsed.hostname || !GREENGRASS_HOSTS.has(parsed.hostname)) {
             throw new config.CredentialsProviderError(`${parsed.hostname} is not a valid container metadata service hostname`, {
                 tryNextLink: false,
                 logger,
             });
         }
-        if (!parsed.protocol || !(parsed.protocol in GREENGRASS_PROTOCOLS)) {
+        if (!parsed.protocol || !GREENGRASS_PROTOCOLS.has(parsed.protocol)) {
             throw new config.CredentialsProviderError(`${parsed.protocol} is not a valid container metadata service protocol`, {
                 tryNextLink: false,
                 logger,
             });
         }
         return {
-            ...parsed,
+            protocol: parsed.protocol,
+            hostname: parsed.hostname,
+            path: parsed.pathname + parsed.search,
             port: parsed.port ? parseInt(parsed.port, 10) : undefined,
         };
     }

package/node_modules/@smithy/credential-provider-imds/dist-es/fromContainerMetadata.js

@@ -1,4 +1,3 @@
-import { parse } from "node:url";
 import { CredentialsProviderError } from "@smithy/core/config";
 import { fromImdsCredentials, isImdsCredentials } from "./remoteProvider/ImdsCredentials";
 import { providerConfigFromInit } from "./remoteProvider/RemoteProviderInit";
@@ -34,14 +33,8 @@ const requestFromEcsImds = async (timeout, options) => {
     return buffer.toString();
 };
 const CMDS_IP = "169.254.170.2";
-const GREENGRASS_HOSTS = {
-    localhost: true,
-    "127.0.0.1": true,
-};
-const GREENGRASS_PROTOCOLS = {
-    "http:": true,
-    "https:": true,
-};
+const GREENGRASS_HOSTS = new Set(["localhost", "127.0.0.1"]);
+const GREENGRASS_PROTOCOLS = new Set(["http:", "https:"]);
 const getCmdsUri = async ({ logger }) => {
     if (process.env[ENV_CMDS_RELATIVE_URI]) {
         return {
@@ -50,21 +43,29 @@ const getCmdsUri = async ({ logger }) => {
         };
     }
     if (process.env[ENV_CMDS_FULL_URI]) {
-        const parsed = parse(process.env[ENV_CMDS_FULL_URI]);
-        if (!parsed.hostname || !(parsed.hostname in GREENGRASS_HOSTS)) {
+        let parsed;
+        try {
+            parsed = new URL(process.env[ENV_CMDS_FULL_URI]);
+        }
+        catch {
+            throw new CredentialsProviderError(`${process.env[ENV_CMDS_FULL_URI]} is not a valid container metadata service URL`, { tryNextLink: false, logger });
+        }
+        if (!parsed.hostname || !GREENGRASS_HOSTS.has(parsed.hostname)) {
             throw new CredentialsProviderError(`${parsed.hostname} is not a valid container metadata service hostname`, {
                 tryNextLink: false,
                 logger,
             });
         }
-        if (!parsed.protocol || !(parsed.protocol in GREENGRASS_PROTOCOLS)) {
+        if (!parsed.protocol || !GREENGRASS_PROTOCOLS.has(parsed.protocol)) {
             throw new CredentialsProviderError(`${parsed.protocol} is not a valid container metadata service protocol`, {
                 tryNextLink: false,
                 logger,
             });
         }
         return {
-            ...parsed,
+            protocol: parsed.protocol,
+            hostname: parsed.hostname,
+            path: parsed.pathname + parsed.search,
             port: parsed.port ? parseInt(parsed.port, 10) : undefined,
         };
     }

package/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/httpRequest.js

@@ -1,8 +1,8 @@
-import { request } from "node:http";
 import { ProviderError } from "@smithy/core/config";
+import { node_http } from "./node-http";
 export function httpRequest(options) {
     return new Promise((resolve, reject) => {
-        const req = request({
+        const req = node_http.request({
             method: "GET",
             ...options,
             hostname: options.hostname?.replace(/^\[(.+)\]$/, "$1"),

package/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/node-http.js

@@ -0,0 +1,2 @@
+import node_http from "node:http";
+export { node_http };

package/node_modules/@smithy/credential-provider-imds/dist-types/remoteProvider/httpRequest.d.ts

@@ -1,4 +1,4 @@
-import { type RequestOptions } from "node:http";
+import type { RequestOptions } from "node:http";
 /**
  * @internal
  */

package/node_modules/@smithy/credential-provider-imds/dist-types/remoteProvider/node-http.d.ts

@@ -0,0 +1,2 @@
+import node_http from "node:http";
+export { node_http };

package/node_modules/@smithy/credential-provider-imds/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/credential-provider-imds",
-  "version": "4.3.5",
+  "version": "4.3.8",
   "description": "AWS credential provider that sources credentials from the EC2 instance metadata service and ECS container metadata service",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -27,8 +27,8 @@
   "license": "Apache-2.0",
   "sideEffects": false,
   "dependencies": {
-    "@smithy/core": "^3.24.5",
-    "@smithy/types": "^4.14.2",
+    "@smithy/core": "^3.24.6",
+    "@smithy/types": "^4.14.3",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/node_modules/@smithy/fetch-http-handler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/fetch-http-handler",
-  "version": "5.4.5",
+  "version": "5.4.6",
   "description": "Provides a way to make requests",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es:cjs'",
@@ -27,12 +27,12 @@
   "module": "./dist-es/index.js",
   "types": "./dist-types/index.d.ts",
   "dependencies": {
-    "@smithy/core": "^3.24.5",
-    "@smithy/types": "^4.14.2",
+    "@smithy/core": "^3.24.6",
+    "@smithy/types": "^4.14.3",
     "tslib": "^2.6.2"
   },
   "devDependencies": {
-    "@smithy/abort-controller": "^4.2.15",
+    "@smithy/abort-controller": "^4.2.16",
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",
     "premove": "4.0.0",