@desplega.ai/agent-swarm 1.152.2 → 1.154.0

package/dist/cli-tcvj7j2r.js

@@ -1,1971 +0,0 @@
-import {
-  require_client,
-  require_config,
-  require_dist_cjs,
-  require_endpoints,
-  require_protocols,
-  require_serde
-} from "./cli-qa66qaf0.js";
-import {
-  __commonJS,
-  __require,
-  __toESM
-} from "./cli-bc05qbss.js";
-
-// node_modules/@smithy/core/dist-cjs/submodules/retry/index.js
-var require_retry = __commonJS(function(exports) {
-  var node_stream = __require("node:stream");
-  var client = require_client();
-  var protocols = require_protocols();
-  var serde = require_serde();
-  var isStreamingPayload = (request) => request?.body instanceof node_stream.Readable || typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream;
-  var CLOCK_SKEW_ERROR_CODES = [
-    "AuthFailure",
-    "InvalidSignatureException",
-    "RequestExpired",
-    "RequestInTheFuture",
-    "RequestTimeTooSkewed",
-    "SignatureDoesNotMatch"
-  ];
-  var THROTTLING_ERROR_CODES = [
-    "BandwidthLimitExceeded",
-    "EC2ThrottledException",
-    "LimitExceededException",
-    "PriorRequestNotComplete",
-    "ProvisionedThroughputExceededException",
-    "RequestLimitExceeded",
-    "RequestThrottled",
-    "RequestThrottledException",
-    "SlowDown",
-    "ThrottledException",
-    "Throttling",
-    "ThrottlingException",
-    "TooManyRequestsException",
-    "TransactionInProgressException"
-  ];
-  var TRANSIENT_ERROR_CODES = ["TimeoutError", "RequestTimeout", "RequestTimeoutException"];
-  var TRANSIENT_ERROR_STATUS_CODES = [500, 502, 503, 504];
-  var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT"];
-  var NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND"];
-  var isRetryableByTrait = (error) => error?.$retryable !== undefined;
-  var isClockSkewError = (error) => CLOCK_SKEW_ERROR_CODES.includes(error.name);
-  var isClockSkewCorrectedError = (error) => error.$metadata?.clockSkewCorrected;
-  var isBrowserNetworkError = (error) => {
-    const errorMessages = new Set([
-      "Failed to fetch",
-      "NetworkError when attempting to fetch resource",
-      "The Internet connection appears to be offline",
-      "Load failed",
-      "Network request failed"
-    ]);
-    const isValid = error && error instanceof TypeError;
-    if (!isValid) {
-      return false;
-    }
-    return errorMessages.has(error.message);
-  };
-  var isThrottlingError = (error) => error.$metadata?.httpStatusCode === 429 || THROTTLING_ERROR_CODES.includes(error.name) || error.$retryable?.throttling == true;
-  var 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 || "") || TRANSIENT_ERROR_STATUS_CODES.includes(error.$metadata?.httpStatusCode || 0) || isBrowserNetworkError(error) || isNodeJsHttp2TransientError(error) || error.cause !== undefined && depth <= 10 && isTransientError(error.cause, depth + 1);
-  var isServerError = (error) => {
-    if (error.$metadata?.httpStatusCode !== undefined) {
-      const statusCode = error.$metadata.httpStatusCode;
-      if (500 <= statusCode && statusCode <= 599 && !isTransientError(error)) {
-        return true;
-      }
-      return false;
-    }
-    return false;
-  };
-  function isNodeJsHttp2TransientError(error) {
-    return error.code === "ERR_HTTP2_STREAM_ERROR" && error.message.includes("NGHTTP2_REFUSED_STREAM");
-  }
-  var DEFAULT_RETRY_DELAY_BASE = 100;
-  var MAXIMUM_RETRY_DELAY = 20 * 1000;
-  var THROTTLING_RETRY_DELAY_BASE = 500;
-  var INITIAL_RETRY_TOKENS = 500;
-  var RETRY_COST = 5;
-  var TIMEOUT_RETRY_COST = 10;
-  var NO_RETRY_INCREMENT = 1;
-  var INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
-  var REQUEST_HEADER = "amz-sdk-request";
-  function parseRetryAfterHeader(response, logger) {
-    if (!protocols.HttpResponse.isInstance(response)) {
-      return;
-    }
-    for (const header of Object.keys(response.headers)) {
-      const h = header.toLowerCase();
-      if (h === "retry-after") {
-        const retryAfter = response.headers[header];
-        let retryAfterSeconds = NaN;
-        if (retryAfter.endsWith("GMT")) {
-          try {
-            const date = serde.parseRfc7231DateTime(retryAfter);
-            retryAfterSeconds = (date.getTime() - Date.now()) / 1000;
-          } catch (e) {
-            logger?.trace?.("Failed to parse retry-after header");
-            logger?.trace?.(e);
-          }
-        } else if (retryAfter.match(/ GMT, ((\d+)|(\d+\.\d+))$/)) {
-          retryAfterSeconds = Number(retryAfter.match(/ GMT, ([\d.]+)$/)?.[1]);
-        } else if (retryAfter.match(/^((\d+)|(\d+\.\d+))$/)) {
-          retryAfterSeconds = Number(retryAfter);
-        } else if (Date.parse(retryAfter) >= Date.now()) {
-          retryAfterSeconds = (Date.parse(retryAfter) - Date.now()) / 1000;
-        }
-        if (isNaN(retryAfterSeconds)) {
-          return;
-        }
-        return new Date(Date.now() + retryAfterSeconds * 1000);
-      } else if (h === "x-amz-retry-after") {
-        const v = response.headers[header];
-        const backoffMilliseconds = Number(v);
-        if (isNaN(backoffMilliseconds)) {
-          logger?.trace?.(`Failed to parse x-amz-retry-after=${v}`);
-          return;
-        }
-        return new Date(Date.now() + backoffMilliseconds);
-      }
-    }
-  }
-  function getRetryAfterHint(response, logger) {
-    return parseRetryAfterHeader(response, logger);
-  }
-  var asSdkError = (error) => {
-    if (error instanceof Error)
-      return error;
-    if (error instanceof Object)
-      return Object.assign(new Error, error);
-    if (typeof error === "string")
-      return new Error(error);
-    return new Error(`AWS SDK error wrapper for ${error}`);
-  };
-  function bindRetryMiddleware(isStreamingPayload2) {
-    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 = protocols.HttpRequest.isInstance(request);
-        if (isRequest) {
-          request.headers[INVOCATION_ID_HEADER] = serde.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 && isStreamingPayload2(request)) {
-              (context.logger instanceof client.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);
-      }
-    };
-  }
-  var cooldown = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-  var isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" && typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" && typeof retryStrategy.recordSuccess !== "undefined";
-  var getRetryErrorInfo = (error, logger) => {
-    const errorInfo = {
-      error,
-      errorType: getRetryErrorType(error)
-    };
-    const retryAfterHint = parseRetryAfterHeader(error.$response, logger);
-    if (retryAfterHint) {
-      errorInfo.retryAfterHint = retryAfterHint;
-    }
-    return errorInfo;
-  };
-  var getRetryErrorType = (error) => {
-    if (isThrottlingError(error))
-      return "THROTTLING";
-    if (isTransientError(error))
-      return "TRANSIENT";
-    if (isServerError(error))
-      return "SERVER_ERROR";
-    return "CLIENT_ERROR";
-  };
-  var retryMiddlewareOptions = {
-    name: "retryMiddleware",
-    tags: ["RETRY"],
-    step: "finalizeRequest",
-    priority: "high",
-    override: true
-  };
-  function bindGetRetryPlugin(isStreamingPayload2) {
-    const retryMiddleware2 = bindRetryMiddleware(isStreamingPayload2);
-    return (options) => ({
-      applyToStack: (clientStack) => {
-        clientStack.add(retryMiddleware2(options), retryMiddlewareOptions);
-      }
-    });
-  }
-
-  class DefaultRateLimiter {
-    static setTimeoutFn = setTimeout;
-    beta;
-    minCapacity;
-    minFillRate;
-    scaleConstant;
-    smooth;
-    enabled = false;
-    availableTokens = 0;
-    lastMaxRate = 0;
-    measuredTxRate = 0;
-    requestCount = 0;
-    fillRate;
-    lastThrottleTime;
-    lastTimestamp = 0;
-    lastTxRateBucket;
-    maxCapacity;
-    timeWindow = 0;
-    constructor(options) {
-      this.beta = options?.beta ?? 0.7;
-      this.minCapacity = options?.minCapacity ?? 1;
-      this.minFillRate = options?.minFillRate ?? 0.5;
-      this.scaleConstant = options?.scaleConstant ?? 0.4;
-      this.smooth = options?.smooth ?? 0.8;
-      this.lastThrottleTime = this.getCurrentTimeInSeconds();
-      this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds());
-      this.fillRate = this.minFillRate;
-      this.maxCapacity = this.minCapacity;
-    }
-    async getSendToken() {
-      return this.acquireTokenBucket(1);
-    }
-    updateClientSendingRate(response) {
-      let calculatedRate;
-      this.updateMeasuredRate();
-      const retryErrorInfo = response;
-      const isThrottling = retryErrorInfo?.errorType === "THROTTLING" || isThrottlingError(retryErrorInfo?.error ?? response);
-      if (isThrottling) {
-        const rateToUse = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate);
-        this.lastMaxRate = rateToUse;
-        this.calculateTimeWindow();
-        this.lastThrottleTime = this.getCurrentTimeInSeconds();
-        calculatedRate = this.cubicThrottle(rateToUse);
-        this.enableTokenBucket();
-      } else {
-        this.calculateTimeWindow();
-        calculatedRate = this.cubicSuccess(this.getCurrentTimeInSeconds());
-      }
-      const newRate = Math.min(calculatedRate, 2 * this.measuredTxRate);
-      this.updateTokenBucketRate(newRate);
-    }
-    getCurrentTimeInSeconds() {
-      return Date.now() / 1000;
-    }
-    async acquireTokenBucket(amount) {
-      if (!this.enabled) {
-        return;
-      }
-      this.refillTokenBucket();
-      while (amount > this.availableTokens) {
-        const delay = (amount - this.availableTokens) / this.fillRate * 1000;
-        await new Promise((resolve) => DefaultRateLimiter.setTimeoutFn(resolve, delay));
-        this.refillTokenBucket();
-      }
-      this.availableTokens = this.availableTokens - amount;
-    }
-    refillTokenBucket() {
-      const timestamp = this.getCurrentTimeInSeconds();
-      if (!this.lastTimestamp) {
-        this.lastTimestamp = timestamp;
-        return;
-      }
-      const fillAmount = (timestamp - this.lastTimestamp) * this.fillRate;
-      this.availableTokens = Math.min(this.maxCapacity, this.availableTokens + fillAmount);
-      this.lastTimestamp = timestamp;
-    }
-    calculateTimeWindow() {
-      this.timeWindow = this.getPrecise(Math.pow(this.lastMaxRate * (1 - this.beta) / this.scaleConstant, 1 / 3));
-    }
-    cubicThrottle(rateToUse) {
-      return this.getPrecise(rateToUse * this.beta);
-    }
-    cubicSuccess(timestamp) {
-      return this.getPrecise(this.scaleConstant * Math.pow(timestamp - this.lastThrottleTime - this.timeWindow, 3) + this.lastMaxRate);
-    }
-    enableTokenBucket() {
-      this.enabled = true;
-    }
-    updateTokenBucketRate(newRate) {
-      this.refillTokenBucket();
-      this.fillRate = Math.max(newRate, this.minFillRate);
-      this.maxCapacity = Math.max(newRate, this.minCapacity);
-      this.availableTokens = Math.min(this.availableTokens, this.maxCapacity);
-    }
-    updateMeasuredRate() {
-      const t = this.getCurrentTimeInSeconds();
-      const timeBucket = Math.floor(t * 2) / 2;
-      this.requestCount++;
-      if (timeBucket > this.lastTxRateBucket) {
-        const currentRate = this.requestCount / (timeBucket - this.lastTxRateBucket);
-        this.measuredTxRate = this.getPrecise(currentRate * this.smooth + this.measuredTxRate * (1 - this.smooth));
-        this.requestCount = 0;
-        this.lastTxRateBucket = timeBucket;
-      }
-    }
-    getPrecise(num) {
-      return parseFloat(num.toFixed(8));
-    }
-  }
-
-  class Retry {
-    static v2026 = typeof process !== "undefined" && process.env?.SMITHY_NEW_RETRIES_2026 === "true";
-    static delay() {
-      return Retry.v2026 ? 50 : 100;
-    }
-    static throttlingDelay() {
-      return Retry.v2026 ? 1000 : 500;
-    }
-    static cost() {
-      return Retry.v2026 ? 14 : 5;
-    }
-    static throttlingCost() {
-      return Retry.v2026 ? 5 : 10;
-    }
-    static modifiedCostType() {
-      return Retry.v2026 ? "THROTTLING" : "TRANSIENT";
-    }
-  }
-
-  class DefaultRetryBackoffStrategy {
-    x = Retry.delay();
-    computeNextBackoffDelay(i) {
-      const b = Math.random();
-      const r = 2;
-      const t_i = b * Math.min(this.x * r ** i, MAXIMUM_RETRY_DELAY);
-      return Math.floor(t_i);
-    }
-    setDelayBase(delay) {
-      this.x = delay;
-    }
-  }
-
-  class DefaultRetryToken {
-    delay;
-    count;
-    cost;
-    longPoll;
-    constructor(delay, count, cost, longPoll) {
-      this.delay = delay;
-      this.count = count;
-      this.cost = cost;
-      this.longPoll = longPoll;
-    }
-    getRetryCount() {
-      return this.count;
-    }
-    getRetryDelay() {
-      return Math.min(MAXIMUM_RETRY_DELAY, this.delay);
-    }
-    getRetryCost() {
-      return this.cost;
-    }
-    isLongPoll() {
-      return this.longPoll;
-    }
-  }
-  exports.RETRY_MODES = undefined;
-  (function(RETRY_MODES) {
-    RETRY_MODES["STANDARD"] = "standard";
-    RETRY_MODES["ADAPTIVE"] = "adaptive";
-  })(exports.RETRY_MODES || (exports.RETRY_MODES = {}));
-  var DEFAULT_MAX_ATTEMPTS = 3;
-  var DEFAULT_RETRY_MODE = exports.RETRY_MODES.STANDARD;
-  var refusal = {
-    incompatible: 1,
-    attempts: 2,
-    capacity: 3
-  };
-  var StandardRetryStrategy$1 = class StandardRetryStrategy2 {
-    mode = exports.RETRY_MODES.STANDARD;
-    capacity = INITIAL_RETRY_TOKENS;
-    retryBackoffStrategy;
-    maxAttemptsProvider;
-    baseDelay;
-    constructor(arg1) {
-      if (typeof arg1 === "number") {
-        this.maxAttemptsProvider = async () => arg1;
-      } else if (typeof arg1 === "function") {
-        this.maxAttemptsProvider = arg1;
-      } else if (arg1 && typeof arg1 === "object") {
-        this.maxAttemptsProvider = async () => arg1.maxAttempts;
-        this.baseDelay = arg1.baseDelay;
-        this.retryBackoffStrategy = arg1.backoff;
-      }
-      this.maxAttemptsProvider ??= async () => DEFAULT_MAX_ATTEMPTS;
-      this.baseDelay ??= Retry.delay();
-      this.retryBackoffStrategy ??= new DefaultRetryBackoffStrategy;
-    }
-    async acquireInitialRetryToken(retryTokenScope) {
-      return new DefaultRetryToken(Retry.delay(), 0, undefined, Retry.v2026 && retryTokenScope.includes(":longpoll"));
-    }
-    async refreshRetryTokenForRetry(token, errorInfo) {
-      const maxAttempts = await this.getMaxAttempts();
-      const retryCode = this.retryCode(token, errorInfo, maxAttempts);
-      const shouldRetry = retryCode === 0;
-      const isLongPoll = token.isLongPoll?.();
-      if (shouldRetry || isLongPoll) {
-        const errorType = errorInfo.errorType;
-        this.retryBackoffStrategy.setDelayBase(errorType === "THROTTLING" ? Retry.throttlingDelay() : this.baseDelay);
-        const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());
-        let retryDelay = delayFromErrorType;
-        if (errorInfo.retryAfterHint instanceof Date) {
-          retryDelay = Math.max(delayFromErrorType, Math.min(errorInfo.retryAfterHint.getTime() - Date.now(), delayFromErrorType + 5000));
-        }
-        if (!shouldRetry) {
-          throw Object.assign(new Error("No retry token available"), {
-            $backoff: Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0
-          });
-        } else {
-          const capacityCost = this.getCapacityCost(errorType);
-          this.capacity -= capacityCost;
-          return new DefaultRetryToken(retryDelay, token.getRetryCount() + 1, capacityCost, token.isLongPoll?.() ?? false);
-        }
-      }
-      throw new Error("No retry token available");
-    }
-    recordSuccess(token) {
-      this.capacity = Math.min(INITIAL_RETRY_TOKENS, this.capacity + (token.getRetryCost() ?? NO_RETRY_INCREMENT));
-    }
-    getCapacity() {
-      return this.capacity;
-    }
-    async maxAttempts() {
-      return this.maxAttemptsProvider();
-    }
-    async getMaxAttempts() {
-      try {
-        return await this.maxAttemptsProvider();
-      } catch (error) {
-        console.warn(`Max attempts provider could not resolve. Using default of ${DEFAULT_MAX_ATTEMPTS}`);
-        return DEFAULT_MAX_ATTEMPTS;
-      }
-    }
-    retryCode(tokenToRenew, errorInfo, maxAttempts) {
-      const attempts = tokenToRenew.getRetryCount() + 1;
-      const retryableStatus = this.isRetryableError(errorInfo.errorType) ? 0 : refusal.incompatible;
-      const attemptStatus = attempts < maxAttempts ? 0 : refusal.attempts;
-      const capacityStatus = this.capacity >= this.getCapacityCost(errorInfo.errorType) ? 0 : refusal.capacity;
-      return retryableStatus || attemptStatus || capacityStatus;
-    }
-    getCapacityCost(errorType) {
-      return errorType === Retry.modifiedCostType() ? Retry.throttlingCost() : Retry.cost();
-    }
-    isRetryableError(errorType) {
-      return errorType === "THROTTLING" || errorType === "TRANSIENT";
-    }
-  };
-  var AdaptiveRetryStrategy$1 = class AdaptiveRetryStrategy2 {
-    mode = exports.RETRY_MODES.ADAPTIVE;
-    rateLimiter;
-    standardRetryStrategy;
-    constructor(maxAttemptsProvider, options) {
-      const { rateLimiter } = options ?? {};
-      this.rateLimiter = rateLimiter ?? new DefaultRateLimiter;
-      this.standardRetryStrategy = options ? new StandardRetryStrategy$1({
-        maxAttempts: typeof maxAttemptsProvider === "number" ? maxAttemptsProvider : 3,
-        ...options
-      }) : new StandardRetryStrategy$1(maxAttemptsProvider);
-    }
-    async acquireInitialRetryToken(retryTokenScope) {
-      const token = await this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
-      await this.rateLimiter.getSendToken();
-      return token;
-    }
-    async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
-      this.rateLimiter.updateClientSendingRate(errorInfo);
-      const token = await this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
-      await this.rateLimiter.getSendToken();
-      return token;
-    }
-    recordSuccess(token) {
-      this.rateLimiter.updateClientSendingRate({});
-      this.standardRetryStrategy.recordSuccess(token);
-    }
-    async maxAttemptsProvider() {
-      return this.standardRetryStrategy.maxAttempts();
-    }
-  };
-
-  class ConfiguredRetryStrategy extends StandardRetryStrategy$1 {
-    computeNextBackoffDelay;
-    constructor(maxAttempts, computeNextBackoffDelay = Retry.delay()) {
-      super(typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts);
-      if (typeof computeNextBackoffDelay === "number") {
-        this.computeNextBackoffDelay = () => computeNextBackoffDelay;
-      } else {
-        this.computeNextBackoffDelay = computeNextBackoffDelay;
-      }
-    }
-    async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
-      const token = await super.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
-      token.getRetryDelay = () => this.computeNextBackoffDelay(token.getRetryCount());
-      return token;
-    }
-  }
-  var getDefaultRetryQuota = (initialRetryTokens, options) => {
-    const MAX_CAPACITY = initialRetryTokens;
-    const noRetryIncrement = NO_RETRY_INCREMENT;
-    const retryCost = RETRY_COST;
-    const timeoutRetryCost = TIMEOUT_RETRY_COST;
-    let availableCapacity = initialRetryTokens;
-    const getCapacityAmount = (error) => error.name === "TimeoutError" ? timeoutRetryCost : retryCost;
-    const hasRetryTokens = (error) => getCapacityAmount(error) <= availableCapacity;
-    const retrieveRetryTokens = (error) => {
-      if (!hasRetryTokens(error)) {
-        throw new Error("No retry token available");
-      }
-      const capacityAmount = getCapacityAmount(error);
-      availableCapacity -= capacityAmount;
-      return capacityAmount;
-    };
-    const releaseRetryTokens = (capacityReleaseAmount) => {
-      availableCapacity += capacityReleaseAmount ?? noRetryIncrement;
-      availableCapacity = Math.min(availableCapacity, MAX_CAPACITY);
-    };
-    return Object.freeze({
-      hasRetryTokens,
-      retrieveRetryTokens,
-      releaseRetryTokens
-    });
-  };
-  var defaultDelayDecider = (delayBase, attempts) => Math.floor(Math.min(MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase));
-  var defaultRetryDecider = (error) => {
-    if (!error) {
-      return false;
-    }
-    return isRetryableByTrait(error) || isClockSkewError(error) || isThrottlingError(error) || isTransientError(error);
-  };
-
-  class StandardRetryStrategy {
-    maxAttemptsProvider;
-    retryDecider;
-    delayDecider;
-    retryQuota;
-    mode = exports.RETRY_MODES.STANDARD;
-    constructor(maxAttemptsProvider, options) {
-      this.maxAttemptsProvider = maxAttemptsProvider;
-      this.retryDecider = options?.retryDecider ?? defaultRetryDecider;
-      this.delayDecider = options?.delayDecider ?? defaultDelayDecider;
-      this.retryQuota = options?.retryQuota ?? getDefaultRetryQuota(INITIAL_RETRY_TOKENS);
-    }
-    shouldRetry(error, attempts, maxAttempts) {
-      return attempts < maxAttempts && this.retryDecider(error) && this.retryQuota.hasRetryTokens(error);
-    }
-    async getMaxAttempts() {
-      let maxAttempts;
-      try {
-        maxAttempts = await this.maxAttemptsProvider();
-      } catch (error) {
-        maxAttempts = DEFAULT_MAX_ATTEMPTS;
-      }
-      return maxAttempts;
-    }
-    async retry(next, args, options) {
-      let retryTokenAmount;
-      let attempts = 0;
-      let totalDelay = 0;
-      const maxAttempts = await this.getMaxAttempts();
-      const { request } = args;
-      if (protocols.HttpRequest.isInstance(request)) {
-        request.headers[INVOCATION_ID_HEADER] = serde.v4();
-      }
-      while (true) {
-        try {
-          if (protocols.HttpRequest.isInstance(request)) {
-            request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
-          }
-          if (options?.beforeRequest) {
-            await options.beforeRequest();
-          }
-          const { response, output } = await next(args);
-          if (options?.afterRequest) {
-            options.afterRequest(response);
-          }
-          this.retryQuota.releaseRetryTokens(retryTokenAmount);
-          output.$metadata.attempts = attempts + 1;
-          output.$metadata.totalRetryDelay = totalDelay;
-          return { response, output };
-        } catch (e) {
-          const err = asSdkError(e);
-          attempts++;
-          if (this.shouldRetry(err, attempts, maxAttempts)) {
-            retryTokenAmount = this.retryQuota.retrieveRetryTokens(err);
-            const delayFromDecider = this.delayDecider(isThrottlingError(err) ? THROTTLING_RETRY_DELAY_BASE : DEFAULT_RETRY_DELAY_BASE, attempts);
-            const delayFromResponse = getDelayFromRetryAfterHeader(err.$response);
-            const delay = Math.max(delayFromResponse || 0, delayFromDecider);
-            totalDelay += delay;
-            await new Promise((resolve) => setTimeout(resolve, delay));
-            continue;
-          }
-          if (!err.$metadata) {
-            err.$metadata = {};
-          }
-          err.$metadata.attempts = attempts;
-          err.$metadata.totalRetryDelay = totalDelay;
-          throw err;
-        }
-      }
-    }
-  }
-  var getDelayFromRetryAfterHeader = (response) => {
-    if (!protocols.HttpResponse.isInstance(response))
-      return;
-    const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
-    if (!retryAfterHeaderName)
-      return;
-    const retryAfter = response.headers[retryAfterHeaderName];
-    const retryAfterSeconds = Number(retryAfter);
-    if (!Number.isNaN(retryAfterSeconds))
-      return retryAfterSeconds * 1000;
-    const retryAfterDate = new Date(retryAfter);
-    return retryAfterDate.getTime() - Date.now();
-  };
-
-  class AdaptiveRetryStrategy extends StandardRetryStrategy {
-    rateLimiter;
-    constructor(maxAttemptsProvider, options) {
-      const { rateLimiter, ...superOptions } = options ?? {};
-      super(maxAttemptsProvider, superOptions);
-      this.rateLimiter = rateLimiter ?? new DefaultRateLimiter;
-      this.mode = exports.RETRY_MODES.ADAPTIVE;
-    }
-    async retry(next, args) {
-      return super.retry(next, args, {
-        beforeRequest: async () => {
-          return this.rateLimiter.getSendToken();
-        },
-        afterRequest: (response) => {
-          this.rateLimiter.updateClientSendingRate(response);
-        }
-      });
-    }
-  }
-  var ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
-  var CONFIG_MAX_ATTEMPTS = "max_attempts";
-  var NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
-    environmentVariableSelector: (env) => {
-      const value = env[ENV_MAX_ATTEMPTS];
-      if (!value)
-        return;
-      const maxAttempt = parseInt(value);
-      if (Number.isNaN(maxAttempt)) {
-        throw new Error(`Environment variable ${ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`);
-      }
-      return maxAttempt;
-    },
-    configFileSelector: (profile) => {
-      const value = profile[CONFIG_MAX_ATTEMPTS];
-      if (!value)
-        return;
-      const maxAttempt = parseInt(value);
-      if (Number.isNaN(maxAttempt)) {
-        throw new Error(`Shared config file entry ${CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`);
-      }
-      return maxAttempt;
-    },
-    default: DEFAULT_MAX_ATTEMPTS
-  };
-  var resolveRetryConfig = (input) => {
-    const { retryStrategy, retryMode } = input;
-    const maxAttempts = client.normalizeProvider(input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
-    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);
-    return Object.assign(input, {
-      maxAttempts,
-      retryStrategy: () => controller ??= getDefault()
-    });
-  };
-  var ENV_RETRY_MODE = "AWS_RETRY_MODE";
-  var CONFIG_RETRY_MODE = "retry_mode";
-  var NODE_RETRY_MODE_CONFIG_OPTIONS = {
-    environmentVariableSelector: (env) => env[ENV_RETRY_MODE],
-    configFileSelector: (profile) => profile[CONFIG_RETRY_MODE],
-    default: DEFAULT_RETRY_MODE
-  };
-  var omitRetryHeadersMiddleware = () => (next) => async (args) => {
-    const { request } = args;
-    if (protocols.HttpRequest.isInstance(request)) {
-      delete request.headers[INVOCATION_ID_HEADER];
-      delete request.headers[REQUEST_HEADER];
-    }
-    return next(args);
-  };
-  var omitRetryHeadersMiddlewareOptions = {
-    name: "omitRetryHeadersMiddleware",
-    tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"],
-    relation: "before",
-    toMiddleware: "awsAuthMiddleware",
-    override: true
-  };
-  var getOmitRetryHeadersPlugin = (options) => ({
-    applyToStack: (clientStack) => {
-      clientStack.addRelativeTo(omitRetryHeadersMiddleware(), omitRetryHeadersMiddlewareOptions);
-    }
-  });
-  var retryMiddleware = bindRetryMiddleware(isStreamingPayload);
-  var getRetryPlugin = bindGetRetryPlugin(isStreamingPayload);
-  exports.AdaptiveRetryStrategy = AdaptiveRetryStrategy$1;
-  exports.CONFIG_MAX_ATTEMPTS = CONFIG_MAX_ATTEMPTS;
-  exports.CONFIG_RETRY_MODE = CONFIG_RETRY_MODE;
-  exports.ConfiguredRetryStrategy = ConfiguredRetryStrategy;
-  exports.DEFAULT_MAX_ATTEMPTS = DEFAULT_MAX_ATTEMPTS;
-  exports.DEFAULT_RETRY_DELAY_BASE = DEFAULT_RETRY_DELAY_BASE;
-  exports.DEFAULT_RETRY_MODE = DEFAULT_RETRY_MODE;
-  exports.DefaultRateLimiter = DefaultRateLimiter;
-  exports.DeprecatedAdaptiveRetryStrategy = AdaptiveRetryStrategy;
-  exports.DeprecatedStandardRetryStrategy = StandardRetryStrategy;
-  exports.ENV_MAX_ATTEMPTS = ENV_MAX_ATTEMPTS;
-  exports.ENV_RETRY_MODE = ENV_RETRY_MODE;
-  exports.INITIAL_RETRY_TOKENS = INITIAL_RETRY_TOKENS;
-  exports.INVOCATION_ID_HEADER = INVOCATION_ID_HEADER;
-  exports.MAXIMUM_RETRY_DELAY = MAXIMUM_RETRY_DELAY;
-  exports.NODE_MAX_ATTEMPT_CONFIG_OPTIONS = NODE_MAX_ATTEMPT_CONFIG_OPTIONS;
-  exports.NODE_RETRY_MODE_CONFIG_OPTIONS = NODE_RETRY_MODE_CONFIG_OPTIONS;
-  exports.NO_RETRY_INCREMENT = NO_RETRY_INCREMENT;
-  exports.REQUEST_HEADER = REQUEST_HEADER;
-  exports.RETRY_COST = RETRY_COST;
-  exports.Retry = Retry;
-  exports.StandardRetryStrategy = StandardRetryStrategy$1;
-  exports.THROTTLING_RETRY_DELAY_BASE = THROTTLING_RETRY_DELAY_BASE;
-  exports.TIMEOUT_RETRY_COST = TIMEOUT_RETRY_COST;
-  exports.defaultDelayDecider = defaultDelayDecider;
-  exports.defaultRetryDecider = defaultRetryDecider;
-  exports.getOmitRetryHeadersPlugin = getOmitRetryHeadersPlugin;
-  exports.getRetryAfterHint = getRetryAfterHint;
-  exports.getRetryPlugin = getRetryPlugin;
-  exports.isBrowserNetworkError = isBrowserNetworkError;
-  exports.isClockSkewCorrectedError = isClockSkewCorrectedError;
-  exports.isClockSkewError = isClockSkewError;
-  exports.isNodeJsHttp2TransientError = isNodeJsHttp2TransientError;
-  exports.isRetryableByTrait = isRetryableByTrait;
-  exports.isServerError = isServerError;
-  exports.isThrottlingError = isThrottlingError;
-  exports.isTransientError = isTransientError;
-  exports.omitRetryHeadersMiddleware = omitRetryHeadersMiddleware;
-  exports.omitRetryHeadersMiddlewareOptions = omitRetryHeadersMiddlewareOptions;
-  exports.resolveRetryConfig = resolveRetryConfig;
-  exports.retryMiddleware = retryMiddleware;
-  exports.retryMiddlewareOptions = retryMiddlewareOptions;
-});
-
-// node_modules/@smithy/core/dist-cjs/index.js
-var require_dist_cjs2 = __commonJS(function(exports) {
-  var types = require_dist_cjs();
-  var protocols = require_protocols();
-  var client = require_client();
-  var getSmithyContext = (context) => context[types.SMITHY_CONTEXT_KEY] || (context[types.SMITHY_CONTEXT_KEY] = {});
-  var resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => {
-    if (!authSchemePreference || authSchemePreference.length === 0) {
-      return candidateAuthOptions;
-    }
-    const preferredAuthOptions = [];
-    for (const preferredSchemeName of authSchemePreference) {
-      for (const candidateAuthOption of candidateAuthOptions) {
-        const candidateAuthSchemeName = candidateAuthOption.schemeId.split("#")[1];
-        if (candidateAuthSchemeName === preferredSchemeName) {
-          preferredAuthOptions.push(candidateAuthOption);
-        }
-      }
-    }
-    for (const candidateAuthOption of candidateAuthOptions) {
-      if (!preferredAuthOptions.find(({ schemeId }) => schemeId === candidateAuthOption.schemeId)) {
-        preferredAuthOptions.push(candidateAuthOption);
-      }
-    }
-    return preferredAuthOptions;
-  };
-  function convertHttpAuthSchemesToMap(httpAuthSchemes) {
-    const map = new Map;
-    for (const scheme of httpAuthSchemes) {
-      map.set(scheme.schemeId, scheme);
-    }
-    return map;
-  }
-  var httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async (args) => {
-    const options = config.httpAuthSchemeProvider(await mwOptions.httpAuthSchemeParametersProvider(config, context, args.input));
-    const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : [];
-    const resolvedOptions = resolveAuthOptions(options, authSchemePreference);
-    const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes);
-    const smithyContext = client.getSmithyContext(context);
-    const failureReasons = [];
-    for (const option of resolvedOptions) {
-      const scheme = authSchemes.get(option.schemeId);
-      if (!scheme) {
-        failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` was not enabled for this service.`);
-        continue;
-      }
-      const identityProvider = scheme.identityProvider(await mwOptions.identityProviderConfigProvider(config));
-      if (!identityProvider) {
-        failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` did not have an IdentityProvider configured.`);
-        continue;
-      }
-      const { identityProperties = {}, signingProperties = {} } = option.propertiesExtractor?.(config, context) || {};
-      option.identityProperties = Object.assign(option.identityProperties || {}, identityProperties);
-      option.signingProperties = Object.assign(option.signingProperties || {}, signingProperties);
-      smithyContext.selectedHttpAuthScheme = {
-        httpAuthOption: option,
-        identity: await identityProvider(option.identityProperties),
-        signer: scheme.signer
-      };
-      break;
-    }
-    if (!smithyContext.selectedHttpAuthScheme) {
-      throw new Error(failureReasons.join(`
-`));
-    }
-    return next(args);
-  };
-  var httpAuthSchemeEndpointRuleSetMiddlewareOptions = {
-    step: "serialize",
-    tags: ["HTTP_AUTH_SCHEME"],
-    name: "httpAuthSchemeMiddleware",
-    override: true,
-    relation: "before",
-    toMiddleware: "endpointV2Middleware"
-  };
-  var getHttpAuthSchemeEndpointRuleSetPlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider }) => ({
-    applyToStack: (clientStack) => {
-      clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, {
-        httpAuthSchemeParametersProvider,
-        identityProviderConfigProvider
-      }), httpAuthSchemeEndpointRuleSetMiddlewareOptions);
-    }
-  });
-  var httpAuthSchemeMiddlewareOptions = {
-    step: "serialize",
-    tags: ["HTTP_AUTH_SCHEME"],
-    name: "httpAuthSchemeMiddleware",
-    override: true,
-    relation: "before",
-    toMiddleware: "serializerMiddleware"
-  };
-  var getHttpAuthSchemePlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider }) => ({
-    applyToStack: (clientStack) => {
-      clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, {
-        httpAuthSchemeParametersProvider,
-        identityProviderConfigProvider
-      }), httpAuthSchemeMiddlewareOptions);
-    }
-  });
-  var defaultErrorHandler = (signingProperties) => (error) => {
-    throw error;
-  };
-  var defaultSuccessHandler = (httpResponse, signingProperties) => {};
-  var httpSigningMiddleware = (config) => (next, context) => async (args) => {
-    if (!protocols.HttpRequest.isInstance(args.request)) {
-      return next(args);
-    }
-    const smithyContext = client.getSmithyContext(context);
-    const scheme = smithyContext.selectedHttpAuthScheme;
-    if (!scheme) {
-      throw new Error(`No HttpAuthScheme was selected: unable to sign request`);
-    }
-    const { httpAuthOption: { signingProperties = {} }, identity, signer } = scheme;
-    const output = await next({
-      ...args,
-      request: await signer.sign(args.request, identity, signingProperties)
-    }).catch((signer.errorHandler || defaultErrorHandler)(signingProperties));
-    (signer.successHandler || defaultSuccessHandler)(output.response, signingProperties);
-    return output;
-  };
-  var httpSigningMiddlewareOptions = {
-    step: "finalizeRequest",
-    tags: ["HTTP_SIGNING"],
-    name: "httpSigningMiddleware",
-    aliases: ["apiKeyMiddleware", "tokenMiddleware", "awsAuthMiddleware"],
-    override: true,
-    relation: "after",
-    toMiddleware: "retryMiddleware"
-  };
-  var getHttpSigningPlugin = (config) => ({
-    applyToStack: (clientStack) => {
-      clientStack.addRelativeTo(httpSigningMiddleware(), httpSigningMiddlewareOptions);
-    }
-  });
-  var normalizeProvider = (input) => {
-    if (typeof input === "function")
-      return input;
-    const promisified = Promise.resolve(input);
-    return () => promisified;
-  };
-  var makePagedClientRequest = async (CommandCtor, client2, input, withCommand = (_) => _, ...args) => {
-    let command = new CommandCtor(input);
-    command = withCommand(command) ?? command;
-    return await client2.send(command, ...args);
-  };
-  function createPaginator(ClientCtor, CommandCtor, inputTokenName, outputTokenName, pageSizeTokenName) {
-    return async function* paginateOperation(config, input, ...additionalArguments) {
-      const _input = input;
-      let token = config.startingToken ?? _input[inputTokenName];
-      let hasNext = true;
-      let page;
-      while (hasNext) {
-        _input[inputTokenName] = token;
-        if (pageSizeTokenName) {
-          _input[pageSizeTokenName] = _input[pageSizeTokenName] ?? config.pageSize;
-        }
-        if (config.client instanceof ClientCtor) {
-          page = await makePagedClientRequest(CommandCtor, config.client, input, config.withCommand, ...additionalArguments);
-        } else {
-          throw new Error(`Invalid client, expected instance of ${ClientCtor.name}`);
-        }
-        yield page;
-        const prevToken = token;
-        token = get(page, outputTokenName);
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-      }
-      return;
-    };
-  }
-  var get = (fromObject, path) => {
-    let cursor = fromObject;
-    const pathComponents = path.split(".");
-    for (const step of pathComponents) {
-      if (!cursor || typeof cursor !== "object") {
-        return;
-      }
-      cursor = cursor[step];
-    }
-    return cursor;
-  };
-  function setFeature(context, feature, value) {
-    if (!context.__smithy_context) {
-      context.__smithy_context = {
-        features: {}
-      };
-    } else if (!context.__smithy_context.features) {
-      context.__smithy_context.features = {};
-    }
-    context.__smithy_context.features[feature] = value;
-  }
-
-  class DefaultIdentityProviderConfig {
-    authSchemes = new Map;
-    constructor(config) {
-      for (const key in config) {
-        const value = config[key];
-        if (value !== undefined) {
-          this.authSchemes.set(key, value);
-        }
-      }
-    }
-    getIdentityProvider(schemeId) {
-      return this.authSchemes.get(schemeId);
-    }
-  }
-
-  class HttpApiKeyAuthSigner {
-    async sign(httpRequest, identity, signingProperties) {
-      if (!signingProperties) {
-        throw new Error("request could not be signed with `apiKey` since the `name` and `in` signer properties are missing");
-      }
-      if (!signingProperties.name) {
-        throw new Error("request could not be signed with `apiKey` since the `name` signer property is missing");
-      }
-      if (!signingProperties.in) {
-        throw new Error("request could not be signed with `apiKey` since the `in` signer property is missing");
-      }
-      if (!identity.apiKey) {
-        throw new Error("request could not be signed with `apiKey` since the `apiKey` is not defined");
-      }
-      const clonedRequest = protocols.HttpRequest.clone(httpRequest);
-      if (signingProperties.in === types.HttpApiKeyAuthLocation.QUERY) {
-        clonedRequest.query[signingProperties.name] = identity.apiKey;
-      } else if (signingProperties.in === types.HttpApiKeyAuthLocation.HEADER) {
-        clonedRequest.headers[signingProperties.name] = signingProperties.scheme ? `${signingProperties.scheme} ${identity.apiKey}` : identity.apiKey;
-      } else {
-        throw new Error("request can only be signed with `apiKey` locations `query` or `header`, " + "but found: `" + signingProperties.in + "`");
-      }
-      return clonedRequest;
-    }
-  }
-
-  class HttpBearerAuthSigner {
-    async sign(httpRequest, identity, signingProperties) {
-      const clonedRequest = protocols.HttpRequest.clone(httpRequest);
-      if (!identity.token) {
-        throw new Error("request could not be signed with `token` since the `token` is not defined");
-      }
-      clonedRequest.headers["Authorization"] = `Bearer ${identity.token}`;
-      return clonedRequest;
-    }
-  }
-
-  class NoAuthSigner {
-    async sign(httpRequest, identity, signingProperties) {
-      return httpRequest;
-    }
-  }
-  var createIsIdentityExpiredFunction = (expirationMs) => function isIdentityExpired2(identity) {
-    return doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
-  };
-  var EXPIRATION_MS = 300000;
-  var isIdentityExpired = createIsIdentityExpiredFunction(EXPIRATION_MS);
-  var doesIdentityRequireRefresh = (identity) => identity.expiration !== undefined;
-  var memoizeIdentityProvider = (provider, isExpired, requiresRefresh) => {
-    if (provider === undefined) {
-      return;
-    }
-    const normalizedProvider = typeof provider !== "function" ? async () => Promise.resolve(provider) : provider;
-    let resolved;
-    let pending;
-    let hasResult;
-    let isConstant = false;
-    const coalesceProvider = async (options) => {
-      if (!pending) {
-        pending = normalizedProvider(options);
-      }
-      try {
-        resolved = await pending;
-        hasResult = true;
-        isConstant = false;
-      } finally {
-        pending = undefined;
-      }
-      return resolved;
-    };
-    if (isExpired === undefined) {
-      return async (options) => {
-        if (!hasResult || options?.forceRefresh) {
-          resolved = await coalesceProvider(options);
-        }
-        return resolved;
-      };
-    }
-    return async (options) => {
-      if (!hasResult || options?.forceRefresh) {
-        resolved = await coalesceProvider(options);
-      }
-      if (isConstant) {
-        return resolved;
-      }
-      if (!requiresRefresh(resolved)) {
-        isConstant = true;
-        return resolved;
-      }
-      if (isExpired(resolved)) {
-        await coalesceProvider(options);
-        return resolved;
-      }
-      return resolved;
-    };
-  };
-  exports.requestBuilder = protocols.requestBuilder;
-  exports.DefaultIdentityProviderConfig = DefaultIdentityProviderConfig;
-  exports.EXPIRATION_MS = EXPIRATION_MS;
-  exports.HttpApiKeyAuthSigner = HttpApiKeyAuthSigner;
-  exports.HttpBearerAuthSigner = HttpBearerAuthSigner;
-  exports.NoAuthSigner = NoAuthSigner;
-  exports.createIsIdentityExpiredFunction = createIsIdentityExpiredFunction;
-  exports.createPaginator = createPaginator;
-  exports.doesIdentityRequireRefresh = doesIdentityRequireRefresh;
-  exports.getHttpAuthSchemeEndpointRuleSetPlugin = getHttpAuthSchemeEndpointRuleSetPlugin;
-  exports.getHttpAuthSchemePlugin = getHttpAuthSchemePlugin;
-  exports.getHttpSigningPlugin = getHttpSigningPlugin;
-  exports.getSmithyContext = getSmithyContext;
-  exports.httpAuthSchemeEndpointRuleSetMiddlewareOptions = httpAuthSchemeEndpointRuleSetMiddlewareOptions;
-  exports.httpAuthSchemeMiddleware = httpAuthSchemeMiddleware;
-  exports.httpAuthSchemeMiddlewareOptions = httpAuthSchemeMiddlewareOptions;
-  exports.httpSigningMiddleware = httpSigningMiddleware;
-  exports.httpSigningMiddlewareOptions = httpSigningMiddlewareOptions;
-  exports.isIdentityExpired = isIdentityExpired;
-  exports.memoizeIdentityProvider = memoizeIdentityProvider;
-  exports.normalizeProvider = normalizeProvider;
-  exports.setFeature = setFeature;
-});
-
-// node_modules/@aws/lambda-invoke-store/dist-cjs/invoke-store.js
-var require_invoke_store = __commonJS(function(exports) {
-  var PROTECTED_KEYS = {
-    REQUEST_ID: Symbol.for("_AWS_LAMBDA_REQUEST_ID"),
-    X_RAY_TRACE_ID: Symbol.for("_AWS_LAMBDA_X_RAY_TRACE_ID"),
-    TENANT_ID: Symbol.for("_AWS_LAMBDA_TENANT_ID")
-  };
-  var NO_GLOBAL_AWS_LAMBDA = ["true", "1"].includes(process.env?.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA ?? "");
-  if (!NO_GLOBAL_AWS_LAMBDA) {
-    globalThis.awslambda = globalThis.awslambda || {};
-  }
-
-  class InvokeStoreBase {
-    static PROTECTED_KEYS = PROTECTED_KEYS;
-    isProtectedKey(key) {
-      return Object.values(PROTECTED_KEYS).includes(key);
-    }
-    getRequestId() {
-      return this.get(PROTECTED_KEYS.REQUEST_ID) ?? "-";
-    }
-    getXRayTraceId() {
-      return this.get(PROTECTED_KEYS.X_RAY_TRACE_ID);
-    }
-    getTenantId() {
-      return this.get(PROTECTED_KEYS.TENANT_ID);
-    }
-  }
-
-  class InvokeStoreSingle extends InvokeStoreBase {
-    currentContext;
-    getContext() {
-      return this.currentContext;
-    }
-    hasContext() {
-      return this.currentContext !== undefined;
-    }
-    get(key) {
-      return this.currentContext?.[key];
-    }
-    set(key, value) {
-      if (this.isProtectedKey(key)) {
-        throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
-      }
-      this.currentContext = this.currentContext || {};
-      this.currentContext[key] = value;
-    }
-    run(context, fn) {
-      this.currentContext = context;
-      return fn();
-    }
-  }
-
-  class InvokeStoreMulti extends InvokeStoreBase {
-    als;
-    static async create() {
-      const instance = new InvokeStoreMulti;
-      const asyncHooks = await import("node:async_hooks");
-      instance.als = new asyncHooks.AsyncLocalStorage;
-      return instance;
-    }
-    getContext() {
-      return this.als.getStore();
-    }
-    hasContext() {
-      return this.als.getStore() !== undefined;
-    }
-    get(key) {
-      return this.als.getStore()?.[key];
-    }
-    set(key, value) {
-      if (this.isProtectedKey(key)) {
-        throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
-      }
-      const store = this.als.getStore();
-      if (!store) {
-        throw new Error("No context available");
-      }
-      store[key] = value;
-    }
-    run(context, fn) {
-      return this.als.run(context, fn);
-    }
-  }
-  exports.InvokeStore = undefined;
-  (function(InvokeStore) {
-    let instance = null;
-    async function getInstanceAsync() {
-      if (!instance) {
-        instance = (async () => {
-          const isMulti = "AWS_LAMBDA_MAX_CONCURRENCY" in process.env;
-          const newInstance = isMulti ? await InvokeStoreMulti.create() : new InvokeStoreSingle;
-          if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda?.InvokeStore) {
-            return globalThis.awslambda.InvokeStore;
-          } else if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda) {
-            globalThis.awslambda.InvokeStore = newInstance;
-            return newInstance;
-          } else {
-            return newInstance;
-          }
-        })();
-      }
-      return instance;
-    }
-    InvokeStore.getInstanceAsync = getInstanceAsync;
-    InvokeStore._testing = process.env.AWS_LAMBDA_BENCHMARK_MODE === "1" ? {
-      reset: () => {
-        instance = null;
-        if (globalThis.awslambda?.InvokeStore) {
-          delete globalThis.awslambda.InvokeStore;
-        }
-        globalThis.awslambda = { InvokeStore: undefined };
-      }
-    } : undefined;
-  })(exports.InvokeStore || (exports.InvokeStore = {}));
-  exports.InvokeStoreBase = InvokeStoreBase;
-});
-
-// node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
-var require_client2 = __commonJS(function(exports) {
-  var __dirname = "/home/runner/work/agent-swarm/agent-swarm/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
-  var retry = require_retry();
-  var protocols = require_protocols();
-  var lambdaInvokeStore = require_invoke_store();
-  var core = require_dist_cjs2();
-  var node_os = __require("node:os");
-  var node_process = __require("node:process");
-  var config = require_config();
-  var promises = __require("node:fs/promises");
-  var node_path = __require("node:path");
-  var endpoints = require_endpoints();
-  var state = {
-    warningEmitted: false
-  };
-  var emitWarningIfUnsupportedVersion = (version) => {
-    if (version && !state.warningEmitted) {
-      if (process.env.AWS_SDK_JS_NODE_VERSION_SUPPORT_WARNING_DISABLED === "true") {
-        state.warningEmitted = true;
-        return;
-      }
-      const userMajorVersion = parseInt(version.substring(1, version.indexOf(".")));
-      const vv = 22;
-      if (userMajorVersion < vv) {
-        state.warningEmitted = true;
-        process.emitWarning(`NodeVersionSupportWarning: The AWS SDK for JavaScript (v3)
-versions published after the first week of January 2027
-will require node >=${vv}. You are running node ${version}.
-
-To continue receiving updates to AWS services, bug fixes,
-and security updates please upgrade to node >=${vv}.
-
-More information can be found at: https://a.co/c895JFp`);
-      }
-    }
-  };
-  var longPollMiddleware = () => (next, context) => async (args) => {
-    context.__retryLongPoll = true;
-    return next(args);
-  };
-  var longPollMiddlewareOptions = {
-    name: "longPollMiddleware",
-    tags: ["RETRY"],
-    step: "initialize",
-    override: true
-  };
-  var getLongPollPlugin = (options) => ({
-    applyToStack: (clientStack) => {
-      clientStack.add(longPollMiddleware(), longPollMiddlewareOptions);
-    }
-  });
-  function setCredentialFeature(credentials, feature, value) {
-    if (!credentials.$source) {
-      credentials.$source = {};
-    }
-    credentials.$source[feature] = value;
-    return credentials;
-  }
-  retry.Retry.v2026 ||= typeof process === "object" && process.env?.AWS_NEW_RETRIES_2026 === "true";
-  function setFeature(context, feature, value) {
-    if (!context.__aws_sdk_context) {
-      context.__aws_sdk_context = {
-        features: {}
-      };
-    } else if (!context.__aws_sdk_context.features) {
-      context.__aws_sdk_context.features = {};
-    }
-    context.__aws_sdk_context.features[feature] = value;
-  }
-  function setTokenFeature(token, feature, value) {
-    if (!token.$source) {
-      token.$source = {};
-    }
-    token.$source[feature] = value;
-    return token;
-  }
-  function resolveHostHeaderConfig(input) {
-    return input;
-  }
-  var hostHeaderMiddleware = (options) => (next) => async (args) => {
-    if (!protocols.HttpRequest.isInstance(args.request))
-      return next(args);
-    const { request } = args;
-    const { handlerProtocol = "" } = options.requestHandler.metadata || {};
-    if (handlerProtocol.indexOf("h2") >= 0 && !request.headers[":authority"]) {
-      delete request.headers["host"];
-      request.headers[":authority"] = request.hostname + (request.port ? ":" + request.port : "");
-    } else if (!request.headers["host"]) {
-      let host = request.hostname;
-      if (request.port != null)
-        host += `:${request.port}`;
-      request.headers["host"] = host;
-    }
-    return next(args);
-  };
-  var hostHeaderMiddlewareOptions = {
-    name: "hostHeaderMiddleware",
-    step: "build",
-    priority: "low",
-    tags: ["HOST"],
-    override: true
-  };
-  var getHostHeaderPlugin = (options) => ({
-    applyToStack: (clientStack) => {
-      clientStack.add(hostHeaderMiddleware(options), hostHeaderMiddlewareOptions);
-    }
-  });
-  var loggerMiddleware = () => (next, context) => async (args) => {
-    try {
-      const response = await next(args);
-      const { clientName, commandName, logger, dynamoDbDocumentClientOptions = {} } = context;
-      const { overrideInputFilterSensitiveLog, overrideOutputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
-      const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
-      const outputFilterSensitiveLog = overrideOutputFilterSensitiveLog ?? context.outputFilterSensitiveLog;
-      const { $metadata, ...outputWithoutMetadata } = response.output;
-      logger?.info?.({
-        clientName,
-        commandName,
-        input: inputFilterSensitiveLog(args.input),
-        output: outputFilterSensitiveLog(outputWithoutMetadata),
-        metadata: $metadata
-      });
-      return response;
-    } catch (error) {
-      const { clientName, commandName, logger, dynamoDbDocumentClientOptions = {} } = context;
-      const { overrideInputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
-      const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
-      logger?.error?.({
-        clientName,
-        commandName,
-        input: inputFilterSensitiveLog(args.input),
-        error,
-        metadata: error.$metadata
-      });
-      throw error;
-    }
-  };
-  var loggerMiddlewareOptions = {
-    name: "loggerMiddleware",
-    tags: ["LOGGER"],
-    step: "initialize",
-    override: true
-  };
-  var getLoggerPlugin = (options) => ({
-    applyToStack: (clientStack) => {
-      clientStack.add(loggerMiddleware(), loggerMiddlewareOptions);
-    }
-  });
-  var recursionDetectionMiddlewareOptions = {
-    step: "build",
-    tags: ["RECURSION_DETECTION"],
-    name: "recursionDetectionMiddleware",
-    override: true,
-    priority: "low"
-  };
-  var TRACE_ID_HEADER_NAME = "X-Amzn-Trace-Id";
-  var ENV_LAMBDA_FUNCTION_NAME = "AWS_LAMBDA_FUNCTION_NAME";
-  var ENV_TRACE_ID = "_X_AMZN_TRACE_ID";
-  var recursionDetectionMiddleware = () => (next) => async (args) => {
-    const { request } = args;
-    if (!protocols.HttpRequest.isInstance(request)) {
-      return next(args);
-    }
-    const traceIdHeader = Object.keys(request.headers ?? {}).find((h) => h.toLowerCase() === TRACE_ID_HEADER_NAME.toLowerCase()) ?? TRACE_ID_HEADER_NAME;
-    if (request.headers.hasOwnProperty(traceIdHeader)) {
-      return next(args);
-    }
-    const functionName = process.env[ENV_LAMBDA_FUNCTION_NAME];
-    const traceIdFromEnv = process.env[ENV_TRACE_ID];
-    const invokeStore = await lambdaInvokeStore.InvokeStore.getInstanceAsync();
-    const traceIdFromInvokeStore = invokeStore?.getXRayTraceId();
-    const traceId = traceIdFromInvokeStore ?? traceIdFromEnv;
-    const nonEmptyString = (str) => typeof str === "string" && str.length > 0;
-    if (nonEmptyString(functionName) && nonEmptyString(traceId)) {
-      request.headers[TRACE_ID_HEADER_NAME] = traceId;
-    }
-    return next({
-      ...args,
-      request
-    });
-  };
-  var getRecursionDetectionPlugin = (options) => ({
-    applyToStack: (clientStack) => {
-      clientStack.add(recursionDetectionMiddleware(), recursionDetectionMiddlewareOptions);
-    }
-  });
-  var DEFAULT_UA_APP_ID = undefined;
-  function isValidUserAgentAppId(appId) {
-    if (appId === undefined) {
-      return true;
-    }
-    return typeof appId === "string" && appId.length <= 50;
-  }
-  function resolveUserAgentConfig(input) {
-    const normalizedAppIdProvider = core.normalizeProvider(input.userAgentAppId ?? DEFAULT_UA_APP_ID);
-    const { customUserAgent } = input;
-    return Object.assign(input, {
-      customUserAgent: typeof customUserAgent === "string" ? [[customUserAgent]] : customUserAgent,
-      userAgentAppId: async () => {
-        const appId = await normalizedAppIdProvider();
-        if (!isValidUserAgentAppId(appId)) {
-          const logger = input.logger?.constructor?.name === "NoOpLogger" || !input.logger ? console : input.logger;
-          if (typeof appId !== "string") {
-            logger?.warn("userAgentAppId must be a string or undefined.");
-          } else if (appId.length > 50) {
-            logger?.warn("The provided userAgentAppId exceeds the maximum length of 50 characters.");
-          }
-        }
-        return appId;
-      }
-    });
-  }
-  var partitionsInfo = { partitions: [{ id: "aws", outputs: { dnsSuffix: "amazonaws.com", dualStackDnsSuffix: "api.aws", implicitGlobalRegion: "us-east-1", name: "aws", supportsDualStack: true, supportsFIPS: true }, regionRegex: "^(us|eu|ap|sa|ca|me|af|il|mx)\\-\\w+\\-\\d+$", regions: { "af-south-1": { description: "Africa (Cape Town)" }, "ap-east-1": { description: "Asia Pacific (Hong Kong)" }, "ap-east-2": { description: "Asia Pacific (Taipei)" }, "ap-northeast-1": { description: "Asia Pacific (Tokyo)" }, "ap-northeast-2": { description: "Asia Pacific (Seoul)" }, "ap-northeast-3": { description: "Asia Pacific (Osaka)" }, "ap-south-1": { description: "Asia Pacific (Mumbai)" }, "ap-south-2": { description: "Asia Pacific (Hyderabad)" }, "ap-southeast-1": { description: "Asia Pacific (Singapore)" }, "ap-southeast-2": { description: "Asia Pacific (Sydney)" }, "ap-southeast-3": { description: "Asia Pacific (Jakarta)" }, "ap-southeast-4": { description: "Asia Pacific (Melbourne)" }, "ap-southeast-5": { description: "Asia Pacific (Malaysia)" }, "ap-southeast-6": { description: "Asia Pacific (New Zealand)" }, "ap-southeast-7": { description: "Asia Pacific (Thailand)" }, "aws-global": { description: "aws global region" }, "ca-central-1": { description: "Canada (Central)" }, "ca-west-1": { description: "Canada West (Calgary)" }, "eu-central-1": { description: "Europe (Frankfurt)" }, "eu-central-2": { description: "Europe (Zurich)" }, "eu-north-1": { description: "Europe (Stockholm)" }, "eu-south-1": { description: "Europe (Milan)" }, "eu-south-2": { description: "Europe (Spain)" }, "eu-west-1": { description: "Europe (Ireland)" }, "eu-west-2": { description: "Europe (London)" }, "eu-west-3": { description: "Europe (Paris)" }, "il-central-1": { description: "Israel (Tel Aviv)" }, "me-central-1": { description: "Middle East (UAE)" }, "me-south-1": { description: "Middle East (Bahrain)" }, "mx-central-1": { description: "Mexico (Central)" }, "sa-east-1": { description: "South America (Sao Paulo)" }, "us-east-1": { description: "US East (N. Virginia)" }, "us-east-2": { description: "US East (Ohio)" }, "us-west-1": { description: "US West (N. California)" }, "us-west-2": { description: "US West (Oregon)" } } }, { id: "aws-cn", outputs: { dnsSuffix: "amazonaws.com.cn", dualStackDnsSuffix: "api.amazonwebservices.com.cn", implicitGlobalRegion: "cn-northwest-1", name: "aws-cn", supportsDualStack: true, supportsFIPS: true }, regionRegex: "^cn\\-\\w+\\-\\d+$", regions: { "aws-cn-global": { description: "aws-cn global region" }, "cn-north-1": { description: "China (Beijing)" }, "cn-northwest-1": { description: "China (Ningxia)" } } }, { id: "aws-eusc", outputs: { dnsSuffix: "amazonaws.eu", dualStackDnsSuffix: "api.amazonwebservices.eu", implicitGlobalRegion: "eusc-de-east-1", name: "aws-eusc", supportsDualStack: true, supportsFIPS: true }, regionRegex: "^eusc\\-(de)\\-\\w+\\-\\d+$", regions: { "eusc-de-east-1": { description: "AWS European Sovereign Cloud (Germany)" } } }, { id: "aws-iso", outputs: { dnsSuffix: "c2s.ic.gov", dualStackDnsSuffix: "api.aws.ic.gov", implicitGlobalRegion: "us-iso-east-1", name: "aws-iso", supportsDualStack: true, supportsFIPS: true }, regionRegex: "^us\\-iso\\-\\w+\\-\\d+$", regions: { "aws-iso-global": { description: "aws-iso global region" }, "us-iso-east-1": { description: "US ISO East" }, "us-iso-west-1": { description: "US ISO WEST" } } }, { id: "aws-iso-b", outputs: { dnsSuffix: "sc2s.sgov.gov", dualStackDnsSuffix: "api.aws.scloud", implicitGlobalRegion: "us-isob-east-1", name: "aws-iso-b", supportsDualStack: true, supportsFIPS: true }, regionRegex: "^us\\-isob\\-\\w+\\-\\d+$", regions: { "aws-iso-b-global": { description: "aws-iso-b global region" }, "us-isob-east-1": { description: "US ISOB East (Ohio)" }, "us-isob-west-1": { description: "US ISOB West" } } }, { id: "aws-iso-e", outputs: { dnsSuffix: "cloud.adc-e.uk", dualStackDnsSuffix: "api.cloud-aws.adc-e.uk", implicitGlobalRegion: "eu-isoe-west-1", name: "aws-iso-e", supportsDualStack: true, supportsFIPS: true }, regionRegex: "^eu\\-isoe\\-\\w+\\-\\d+$", regions: { "aws-iso-e-global": { description: "aws-iso-e global region" }, "eu-isoe-west-1": { description: "EU ISOE West" } } }, { id: "aws-iso-f", outputs: { dnsSuffix: "csp.hci.ic.gov", dualStackDnsSuffix: "api.aws.hci.ic.gov", implicitGlobalRegion: "us-isof-south-1", name: "aws-iso-f", supportsDualStack: true, supportsFIPS: true }, regionRegex: "^us\\-isof\\-\\w+\\-\\d+$", regions: { "aws-iso-f-global": { description: "aws-iso-f global region" }, "us-isof-east-1": { description: "US ISOF EAST" }, "us-isof-south-1": { description: "US ISOF SOUTH" } } }, { id: "aws-us-gov", outputs: { dnsSuffix: "amazonaws.com", dualStackDnsSuffix: "api.aws", implicitGlobalRegion: "us-gov-west-1", name: "aws-us-gov", supportsDualStack: true, supportsFIPS: true }, regionRegex: "^us\\-gov\\-\\w+\\-\\d+$", regions: { "aws-us-gov-global": { description: "aws-us-gov global region" }, "us-gov-east-1": { description: "AWS GovCloud (US-East)" }, "us-gov-west-1": { description: "AWS GovCloud (US-West)" } } }], version: "1.1" };
-  var selectedPartitionsInfo = partitionsInfo;
-  var selectedUserAgentPrefix = "";
-  var partition = (value) => {
-    const { partitions } = selectedPartitionsInfo;
-    for (const partition2 of partitions) {
-      const { regions, outputs } = partition2;
-      for (const [region, regionData] of Object.entries(regions)) {
-        if (region === value) {
-          return {
-            ...outputs,
-            ...regionData
-          };
-        }
-      }
-    }
-    for (const partition2 of partitions) {
-      const { regionRegex, outputs } = partition2;
-      if (new RegExp(regionRegex).test(value)) {
-        return {
-          ...outputs
-        };
-      }
-    }
-    const DEFAULT_PARTITION = partitions.find((partition2) => partition2.id === "aws");
-    if (!DEFAULT_PARTITION) {
-      throw new Error("Provided region was not found in the partition array or regex," + " and default partition with id 'aws' doesn't exist.");
-    }
-    return {
-      ...DEFAULT_PARTITION.outputs
-    };
-  };
-  var setPartitionInfo = (partitionsInfo2, userAgentPrefix = "") => {
-    selectedPartitionsInfo = partitionsInfo2;
-    selectedUserAgentPrefix = userAgentPrefix;
-  };
-  var useDefaultPartitionInfo = () => {
-    setPartitionInfo(partitionsInfo, "");
-  };
-  var getUserAgentPrefix = () => selectedUserAgentPrefix;
-  var ACCOUNT_ID_ENDPOINT_REGEX = /\d{12}\.ddb/;
-  async function checkFeatures(context, config2, args) {
-    const request = args.request;
-    if (request?.headers?.["smithy-protocol"] === "rpc-v2-cbor") {
-      setFeature(context, "PROTOCOL_RPC_V2_CBOR", "M");
-    }
-    if (typeof config2.retryStrategy === "function") {
-      const retryStrategy = await config2.retryStrategy();
-      if (typeof retryStrategy.mode === "string") {
-        switch (retryStrategy.mode) {
-          case retry.RETRY_MODES.ADAPTIVE:
-            setFeature(context, "RETRY_MODE_ADAPTIVE", "F");
-            break;
-          case retry.RETRY_MODES.STANDARD:
-            setFeature(context, "RETRY_MODE_STANDARD", "E");
-            break;
-        }
-      }
-    }
-    if (typeof config2.accountIdEndpointMode === "function") {
-      const endpointV2 = context.endpointV2;
-      if (String(endpointV2?.url?.hostname).match(ACCOUNT_ID_ENDPOINT_REGEX)) {
-        setFeature(context, "ACCOUNT_ID_ENDPOINT", "O");
-      }
-      switch (await config2.accountIdEndpointMode?.()) {
-        case "disabled":
-          setFeature(context, "ACCOUNT_ID_MODE_DISABLED", "Q");
-          break;
-        case "preferred":
-          setFeature(context, "ACCOUNT_ID_MODE_PREFERRED", "P");
-          break;
-        case "required":
-          setFeature(context, "ACCOUNT_ID_MODE_REQUIRED", "R");
-          break;
-      }
-    }
-    const identity = context.__smithy_context?.selectedHttpAuthScheme?.identity;
-    if (identity?.$source) {
-      const credentials = identity;
-      if (credentials.accountId) {
-        setFeature(context, "RESOLVED_ACCOUNT_ID", "T");
-      }
-      for (const [key, value] of Object.entries(credentials.$source ?? {})) {
-        setFeature(context, key, value);
-      }
-    }
-  }
-  var USER_AGENT = "user-agent";
-  var X_AMZ_USER_AGENT = "x-amz-user-agent";
-  var SPACE = " ";
-  var UA_NAME_SEPARATOR = "/";
-  var UA_NAME_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w]/g;
-  var UA_VALUE_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w#]/g;
-  var UA_ESCAPE_CHAR = "-";
-  var BYTE_LIMIT = 1024;
-  function encodeFeatures(features) {
-    let buffer = "";
-    for (const key in features) {
-      const val = features[key];
-      if (buffer.length + val.length + 1 <= BYTE_LIMIT) {
-        if (buffer.length) {
-          buffer += "," + val;
-        } else {
-          buffer += val;
-        }
-        continue;
-      }
-      break;
-    }
-    return buffer;
-  }
-  var userAgentMiddleware = (options) => (next, context) => async (args) => {
-    const { request } = args;
-    if (!protocols.HttpRequest.isInstance(request)) {
-      return next(args);
-    }
-    const { headers } = request;
-    const userAgent = context?.userAgent?.map(escapeUserAgent) || [];
-    const defaultUserAgent2 = (await options.defaultUserAgentProvider()).map(escapeUserAgent);
-    await checkFeatures(context, options, args);
-    const awsContext = context;
-    defaultUserAgent2.push(`m/${encodeFeatures(Object.assign({}, context.__smithy_context?.features, awsContext.__aws_sdk_context?.features))}`);
-    const customUserAgent = options?.customUserAgent?.map(escapeUserAgent) || [];
-    const appId = await options.userAgentAppId();
-    if (appId) {
-      defaultUserAgent2.push(escapeUserAgent([`app`, `${appId}`]));
-    }
-    const prefix = getUserAgentPrefix();
-    const sdkUserAgentValue = (prefix ? [prefix] : []).concat([...defaultUserAgent2, ...userAgent, ...customUserAgent]).join(SPACE);
-    const normalUAValue = [
-      ...defaultUserAgent2.filter((section) => section.startsWith("aws-sdk-")),
-      ...customUserAgent
-    ].join(SPACE);
-    if (options.runtime !== "browser") {
-      if (normalUAValue) {
-        headers[X_AMZ_USER_AGENT] = headers[X_AMZ_USER_AGENT] ? `${headers[USER_AGENT]} ${normalUAValue}` : normalUAValue;
-      }
-      headers[USER_AGENT] = sdkUserAgentValue;
-    } else {
-      headers[X_AMZ_USER_AGENT] = sdkUserAgentValue;
-    }
-    return next({
-      ...args,
-      request
-    });
-  };
-  var escapeUserAgent = (userAgentPair) => {
-    const name = userAgentPair[0].split(UA_NAME_SEPARATOR).map((part) => part.replace(UA_NAME_ESCAPE_REGEX, UA_ESCAPE_CHAR)).join(UA_NAME_SEPARATOR);
-    const version = userAgentPair[1]?.replace(UA_VALUE_ESCAPE_REGEX, UA_ESCAPE_CHAR);
-    const prefixSeparatorIndex = name.indexOf(UA_NAME_SEPARATOR);
-    const prefix = name.substring(0, prefixSeparatorIndex);
-    let uaName = name.substring(prefixSeparatorIndex + 1);
-    if (prefix === "api") {
-      uaName = uaName.toLowerCase();
-    }
-    return [prefix, uaName, version].filter((item) => item && item.length > 0).reduce((acc, item, index) => {
-      switch (index) {
-        case 0:
-          return item;
-        case 1:
-          return `${acc}/${item}`;
-        default:
-          return `${acc}#${item}`;
-      }
-    }, "");
-  };
-  var getUserAgentMiddlewareOptions = {
-    name: "getUserAgentMiddleware",
-    step: "build",
-    priority: "low",
-    tags: ["SET_USER_AGENT", "USER_AGENT"],
-    override: true
-  };
-  var getUserAgentPlugin = (config2) => ({
-    applyToStack: (clientStack) => {
-      clientStack.add(userAgentMiddleware(config2), getUserAgentMiddlewareOptions);
-    }
-  });
-  var getRuntimeUserAgentPair = () => {
-    const runtimesToCheck = ["deno", "bun", "llrt"];
-    for (const runtime of runtimesToCheck) {
-      if (node_process.versions[runtime]) {
-        return [`md/${runtime}`, node_process.versions[runtime]];
-      }
-    }
-    return ["md/nodejs", node_process.versions.node];
-  };
-  var getNodeModulesParentDirs = (dirname) => {
-    const cwd = process.cwd();
-    if (!dirname) {
-      return [cwd];
-    }
-    const normalizedPath = node_path.normalize(dirname);
-    const parts = normalizedPath.split(node_path.sep);
-    const nodeModulesIndex = parts.indexOf("node_modules");
-    const parentDir = nodeModulesIndex !== -1 ? parts.slice(0, nodeModulesIndex).join(node_path.sep) : normalizedPath;
-    if (cwd === parentDir) {
-      return [cwd];
-    }
-    return [parentDir, cwd];
-  };
-  var SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*)?$/;
-  var getSanitizedTypeScriptVersion = (version = "") => {
-    const match = version.match(SEMVER_REGEX);
-    if (!match) {
-      return;
-    }
-    const [major, minor, patch, prerelease] = [match[1], match[2], match[3], match[4]];
-    return prerelease ? `${major}.${minor}.${patch}-${prerelease}` : `${major}.${minor}.${patch}`;
-  };
-  var ALLOWED_PREFIXES = ["^", "~", ">=", "<=", ">", "<"];
-  var ALLOWED_DIST_TAGS = ["latest", "beta", "dev", "rc", "insiders", "next"];
-  var getSanitizedDevTypeScriptVersion = (version = "") => {
-    if (ALLOWED_DIST_TAGS.includes(version)) {
-      return version;
-    }
-    const prefix = ALLOWED_PREFIXES.find((p) => version.startsWith(p)) ?? "";
-    const sanitizedTypeScriptVersion = getSanitizedTypeScriptVersion(version.slice(prefix.length));
-    if (!sanitizedTypeScriptVersion) {
-      return;
-    }
-    return `${prefix}${sanitizedTypeScriptVersion}`;
-  };
-  var tscVersion;
-  var TS_PACKAGE_JSON = node_path.join("node_modules", "typescript", "package.json");
-  var getTypeScriptUserAgentPair = async () => {
-    if (tscVersion === null) {
-      return;
-    } else if (typeof tscVersion === "string") {
-      return ["md/tsc", tscVersion];
-    }
-    let isTypeScriptDetectionDisabled = false;
-    try {
-      isTypeScriptDetectionDisabled = config.booleanSelector(process.env, "AWS_SDK_JS_TYPESCRIPT_DETECTION_DISABLED", config.SelectorType.ENV) || false;
-    } catch {}
-    if (isTypeScriptDetectionDisabled) {
-      tscVersion = null;
-      return;
-    }
-    const dirname = typeof __dirname !== "undefined" ? __dirname : undefined;
-    const nodeModulesParentDirs = getNodeModulesParentDirs(dirname);
-    let versionFromApp;
-    for (const nodeModulesParentDir of nodeModulesParentDirs) {
-      try {
-        const appPackageJsonPath = node_path.join(nodeModulesParentDir, "package.json");
-        const packageJson = await promises.readFile(appPackageJsonPath, "utf-8");
-        const { dependencies, devDependencies } = JSON.parse(packageJson);
-        const version = devDependencies?.typescript ?? dependencies?.typescript;
-        if (typeof version !== "string") {
-          continue;
-        }
-        versionFromApp = version;
-        break;
-      } catch {}
-    }
-    if (!versionFromApp) {
-      tscVersion = null;
-      return;
-    }
-    let versionFromNodeModules;
-    for (const nodeModulesParentDir of nodeModulesParentDirs) {
-      try {
-        const tsPackageJsonPath = node_path.join(nodeModulesParentDir, TS_PACKAGE_JSON);
-        const packageJson = await promises.readFile(tsPackageJsonPath, "utf-8");
-        const { version } = JSON.parse(packageJson);
-        const sanitizedVersion2 = getSanitizedTypeScriptVersion(version);
-        if (typeof sanitizedVersion2 !== "string") {
-          continue;
-        }
-        versionFromNodeModules = sanitizedVersion2;
-        break;
-      } catch {}
-    }
-    if (versionFromNodeModules) {
-      tscVersion = versionFromNodeModules;
-      return ["md/tsc", tscVersion];
-    }
-    const sanitizedVersion = getSanitizedDevTypeScriptVersion(versionFromApp);
-    if (typeof sanitizedVersion !== "string") {
-      tscVersion = null;
-      return;
-    }
-    tscVersion = `dev_${sanitizedVersion}`;
-    return ["md/tsc", tscVersion];
-  };
-  var crtAvailability = {
-    isCrtAvailable: false
-  };
-  var isCrtAvailable = () => {
-    if (crtAvailability.isCrtAvailable) {
-      return ["md/crt-avail"];
-    }
-    return null;
-  };
-  var createDefaultUserAgentProvider = ({ serviceId, clientVersion }) => {
-    const runtimeUserAgentPair = getRuntimeUserAgentPair();
-    return async (config2) => {
-      const sections = [
-        ["aws-sdk-js", clientVersion],
-        ["ua", "2.1"],
-        [`os/${node_os.platform()}`, node_os.release()],
-        ["lang/js"],
-        runtimeUserAgentPair
-      ];
-      const typescriptUserAgentPair = await getTypeScriptUserAgentPair();
-      if (typescriptUserAgentPair) {
-        sections.push(typescriptUserAgentPair);
-      }
-      const crtAvailable = isCrtAvailable();
-      if (crtAvailable) {
-        sections.push(crtAvailable);
-      }
-      if (serviceId) {
-        sections.push([`api/${serviceId}`, clientVersion]);
-      }
-      if (node_process.env.AWS_EXECUTION_ENV) {
-        sections.push([`exec-env/${node_process.env.AWS_EXECUTION_ENV}`]);
-      }
-      const appId = await config2?.userAgentAppId?.();
-      const resolvedUserAgent = appId ? [...sections, [`app/${appId}`]] : [...sections];
-      return resolvedUserAgent;
-    };
-  };
-  var defaultUserAgent = createDefaultUserAgentProvider;
-  var UA_APP_ID_ENV_NAME = "AWS_SDK_UA_APP_ID";
-  var UA_APP_ID_INI_NAME = "sdk_ua_app_id";
-  var UA_APP_ID_INI_NAME_DEPRECATED = "sdk-ua-app-id";
-  var NODE_APP_ID_CONFIG_OPTIONS = {
-    environmentVariableSelector: (env) => env[UA_APP_ID_ENV_NAME],
-    configFileSelector: (profile) => profile[UA_APP_ID_INI_NAME] ?? profile[UA_APP_ID_INI_NAME_DEPRECATED],
-    default: DEFAULT_UA_APP_ID
-  };
-  var createUserAgentStringParsingProvider = ({ serviceId, clientVersion }) => async (config2) => {
-    const module2 = await import("./es5-tj3tn4jj.js").then((m)=>__toESM(m.default));
-    const parse = module2.parse ?? module2.default.parse ?? (() => "");
-    const parsedUA = typeof window !== "undefined" && window?.navigator?.userAgent ? parse(window.navigator.userAgent) : undefined;
-    const sections = [
-      ["aws-sdk-js", clientVersion],
-      ["ua", "2.1"],
-      [`os/${parsedUA?.os?.name || "other"}`, parsedUA?.os?.version],
-      ["lang/js"],
-      ["md/browser", `${parsedUA?.browser?.name ?? "unknown"}_${parsedUA?.browser?.version ?? "unknown"}`]
-    ];
-    if (serviceId) {
-      sections.push([`api/${serviceId}`, clientVersion]);
-    }
-    const appId = await config2?.userAgentAppId?.();
-    if (appId) {
-      sections.push([`app/${appId}`]);
-    }
-    return sections;
-  };
-  var fallback = {
-    os(ua) {
-      if (/iPhone|iPad|iPod/.test(ua))
-        return "iOS";
-      if (/Macintosh|Mac OS X/.test(ua))
-        return "macOS";
-      if (/Windows NT/.test(ua))
-        return "Windows";
-      if (/Android/.test(ua))
-        return "Android";
-      if (/Linux/.test(ua))
-        return "Linux";
-      return;
-    },
-    browser(ua) {
-      if (/EdgiOS|EdgA|Edg\//.test(ua))
-        return "Microsoft Edge";
-      if (/Firefox\//.test(ua))
-        return "Firefox";
-      if (/Chrome\//.test(ua))
-        return "Chrome";
-      if (/Safari\//.test(ua))
-        return "Safari";
-      return;
-    }
-  };
-  var isVirtualHostableS3Bucket = (value, allowSubDomains = false) => {
-    if (allowSubDomains) {
-      for (const label of value.split(".")) {
-        if (!isVirtualHostableS3Bucket(label)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    if (!endpoints.isValidHostLabel(value)) {
-      return false;
-    }
-    if (value.length < 3 || value.length > 63) {
-      return false;
-    }
-    if (value !== value.toLowerCase()) {
-      return false;
-    }
-    if (endpoints.isIpAddress(value)) {
-      return false;
-    }
-    return true;
-  };
-  var ARN_DELIMITER = ":";
-  var RESOURCE_DELIMITER = "/";
-  var parseArn = (value) => {
-    const segments = value.split(ARN_DELIMITER);
-    if (segments.length < 6)
-      return null;
-    const [arn, partition2, service, region, accountId, ...resourcePath] = segments;
-    if (arn !== "arn" || partition2 === "" || service === "" || resourcePath.join(ARN_DELIMITER) === "")
-      return null;
-    const resourceId = resourcePath.map((resource) => resource.split(RESOURCE_DELIMITER)).flat();
-    return {
-      partition: partition2,
-      service,
-      region,
-      accountId,
-      resourceId
-    };
-  };
-  var awsEndpointFunctions = {
-    isVirtualHostableS3Bucket,
-    parseArn,
-    partition
-  };
-  endpoints.customEndpointFunctions.aws = awsEndpointFunctions;
-  var resolveDefaultAwsRegionalEndpointsConfig = (input) => {
-    if (typeof input.endpointProvider !== "function") {
-      throw new Error("@aws-sdk/util-endpoint - endpointProvider and endpoint missing in config for this client.");
-    }
-    const { endpoint } = input;
-    if (endpoint === undefined) {
-      input.endpoint = async () => {
-        return toEndpointV1(input.endpointProvider({
-          Region: typeof input.region === "function" ? await input.region() : input.region,
-          UseDualStack: typeof input.useDualstackEndpoint === "function" ? await input.useDualstackEndpoint() : input.useDualstackEndpoint,
-          UseFIPS: typeof input.useFipsEndpoint === "function" ? await input.useFipsEndpoint() : input.useFipsEndpoint,
-          Endpoint: undefined
-        }, { logger: input.logger }));
-      };
-    }
-    return input;
-  };
-  var toEndpointV1 = (endpoint) => protocols.parseUrl(endpoint.url);
-  function stsRegionDefaultResolver(loaderConfig = {}) {
-    return config.loadConfig({
-      ...config.NODE_REGION_CONFIG_OPTIONS,
-      async default() {
-        if (!warning.silence) {
-          console.warn("@aws-sdk - WARN - default STS region of us-east-1 used. See @aws-sdk/credential-providers README and set a region explicitly.");
-        }
-        return "us-east-1";
-      }
-    }, { ...config.NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig });
-  }
-  var warning = {
-    silence: false
-  };
-  var getAwsRegionExtensionConfiguration = (runtimeConfig) => {
-    return {
-      setRegion(region) {
-        runtimeConfig.region = region;
-      },
-      region() {
-        return runtimeConfig.region;
-      }
-    };
-  };
-  var resolveAwsRegionExtensionConfiguration = (awsRegionExtensionConfiguration) => {
-    return {
-      region: awsRegionExtensionConfiguration.region()
-    };
-  };
-  exports.NODE_REGION_CONFIG_FILE_OPTIONS = config.NODE_REGION_CONFIG_FILE_OPTIONS;
-  exports.NODE_REGION_CONFIG_OPTIONS = config.NODE_REGION_CONFIG_OPTIONS;
-  exports.REGION_ENV_NAME = config.REGION_ENV_NAME;
-  exports.REGION_INI_NAME = config.REGION_INI_NAME;
-  exports.resolveRegionConfig = config.resolveRegionConfig;
-  exports.EndpointError = endpoints.EndpointError;
-  exports.isIpAddress = endpoints.isIpAddress;
-  exports.resolveEndpoint = endpoints.resolveEndpoint;
-  exports.DEFAULT_UA_APP_ID = DEFAULT_UA_APP_ID;
-  exports.NODE_APP_ID_CONFIG_OPTIONS = NODE_APP_ID_CONFIG_OPTIONS;
-  exports.UA_APP_ID_ENV_NAME = UA_APP_ID_ENV_NAME;
-  exports.UA_APP_ID_INI_NAME = UA_APP_ID_INI_NAME;
-  exports.awsEndpointFunctions = awsEndpointFunctions;
-  exports.createDefaultUserAgentProvider = createDefaultUserAgentProvider;
-  exports.createUserAgentStringParsingProvider = createUserAgentStringParsingProvider;
-  exports.crtAvailability = crtAvailability;
-  exports.defaultUserAgent = defaultUserAgent;
-  exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion;
-  exports.fallback = fallback;
-  exports.getAwsRegionExtensionConfiguration = getAwsRegionExtensionConfiguration;
-  exports.getHostHeaderPlugin = getHostHeaderPlugin;
-  exports.getLoggerPlugin = getLoggerPlugin;
-  exports.getLongPollPlugin = getLongPollPlugin;
-  exports.getRecursionDetectionPlugin = getRecursionDetectionPlugin;
-  exports.getUserAgentMiddlewareOptions = getUserAgentMiddlewareOptions;
-  exports.getUserAgentPlugin = getUserAgentPlugin;
-  exports.getUserAgentPrefix = getUserAgentPrefix;
-  exports.hostHeaderMiddleware = hostHeaderMiddleware;
-  exports.hostHeaderMiddlewareOptions = hostHeaderMiddlewareOptions;
-  exports.isVirtualHostableS3Bucket = isVirtualHostableS3Bucket;
-  exports.loggerMiddleware = loggerMiddleware;
-  exports.loggerMiddlewareOptions = loggerMiddlewareOptions;
-  exports.parseArn = parseArn;
-  exports.partition = partition;
-  exports.recursionDetectionMiddleware = recursionDetectionMiddleware;
-  exports.recursionDetectionMiddlewareOptions = recursionDetectionMiddlewareOptions;
-  exports.resolveAwsRegionExtensionConfiguration = resolveAwsRegionExtensionConfiguration;
-  exports.resolveDefaultAwsRegionalEndpointsConfig = resolveDefaultAwsRegionalEndpointsConfig;
-  exports.resolveHostHeaderConfig = resolveHostHeaderConfig;
-  exports.resolveUserAgentConfig = resolveUserAgentConfig;
-  exports.setCredentialFeature = setCredentialFeature;
-  exports.setFeature = setFeature;
-  exports.setPartitionInfo = setPartitionInfo;
-  exports.setTokenFeature = setTokenFeature;
-  exports.state = state;
-  exports.stsRegionDefaultResolver = stsRegionDefaultResolver;
-  exports.stsRegionWarning = warning;
-  exports.toEndpointV1 = toEndpointV1;
-  exports.useDefaultPartitionInfo = useDefaultPartitionInfo;
-  exports.userAgentMiddleware = userAgentMiddleware;
-});
-
-export { require_retry, require_dist_cjs2 as require_dist_cjs, require_client2 as require_client };