@aws/lsp-codewhisperer 0.0.27 → 0.0.28

package/node_modules/{@smithy → @amzn/codewhisperer-streaming/node_modules/@smithy}/node-http-handler/dist-es/node-http-handler.js

@@ -7,6 +7,7 @@ import { getTransformedHeaders } from "./get-transformed-headers";
 import { setConnectionTimeout } from "./set-connection-timeout";
 import { setSocketKeepAlive } from "./set-socket-keep-alive";
 import { setSocketTimeout } from "./set-socket-timeout";
+import { timing } from "./timing";
 import { writeRequestBody } from "./write-request-body";
 export const DEFAULT_REQUEST_TIMEOUT = 0;
 export class NodeHttpHandler {
@@ -16,7 +17,7 @@ export class NodeHttpHandler {
         }
         return new NodeHttpHandler(instanceOrOptions);
     }
-    static checkSocketUsage(agent, socketWarningTimestamp) {
+    static checkSocketUsage(agent, socketWarningTimestamp, logger = console) {
         const { sockets, requests, maxSockets } = agent;
         if (typeof maxSockets !== "number" || maxSockets === Infinity) {
             return socketWarningTimestamp;
@@ -30,7 +31,9 @@ export class NodeHttpHandler {
                 const socketsInUse = sockets[origin]?.length ?? 0;
                 const requestsEnqueued = requests[origin]?.length ?? 0;
                 if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) {
-                    console.warn("@smithy/node-http-handler:WARN", `socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.`, "See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html", "or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.");
+                    logger?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.
+See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html
+or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`);
                     return Date.now();
                 }
             }
@@ -72,6 +75,7 @@ export class NodeHttpHandler {
                 }
                 return new hsAgent({ keepAlive, maxSockets, ...httpsAgent });
             })(),
+            logger: console,
         };
     }
     destroy() {
@@ -82,16 +86,17 @@ export class NodeHttpHandler {
         if (!this.config) {
             this.config = await this.configProvider;
         }
-        let socketCheckTimeoutId;
         return new Promise((_resolve, _reject) => {
             let writeRequestBodyPromise = undefined;
+            const timeouts = [];
             const resolve = async (arg) => {
                 await writeRequestBodyPromise;
-                clearTimeout(socketCheckTimeoutId);
+                timeouts.forEach(timing.clearTimeout);
                 _resolve(arg);
             };
             const reject = async (arg) => {
                 await writeRequestBodyPromise;
+                timeouts.forEach(timing.clearTimeout);
                 _reject(arg);
             };
             if (!this.config) {
@@ -105,9 +110,10 @@ export class NodeHttpHandler {
             }
             const isSSL = request.protocol === "https:";
             const agent = isSSL ? this.config.httpsAgent : this.config.httpAgent;
-            socketCheckTimeoutId = setTimeout(() => {
-                this.socketWarningTimestamp = NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp);
-            }, this.config.socketAcquisitionWarningTimeout ?? (this.config.requestTimeout ?? 2000) + (this.config.connectionTimeout ?? 1000));
+            timeouts.push(timing.setTimeout(() => {
+                this.socketWarningTimestamp = NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, this.config.logger);
+            }, this.config.socketAcquisitionWarningTimeout ??
+                (this.config.requestTimeout ?? 2000) + (this.config.connectionTimeout ?? 1000)));
             const queryString = buildQueryString(request.query || {});
             let auth = undefined;
             if (request.username != null || request.password != null) {
@@ -122,9 +128,16 @@ export class NodeHttpHandler {
             if (request.fragment) {
                 path += `#${request.fragment}`;
             }
+            let hostname = request.hostname ?? "";
+            if (hostname[0] === "[" && hostname.endsWith("]")) {
+                hostname = request.hostname.slice(1, -1);
+            }
+            else {
+                hostname = request.hostname;
+            }
             const nodeHttpsOptions = {
                 headers: request.headers,
-                host: request.hostname,
+                host: hostname,
                 method: request.method,
                 path,
                 port: request.port,
@@ -149,24 +162,35 @@ export class NodeHttpHandler {
                     reject(err);
                 }
             });
-            setConnectionTimeout(req, reject, this.config.connectionTimeout);
-            setSocketTimeout(req, reject, this.config.requestTimeout);
             if (abortSignal) {
-                abortSignal.onabort = () => {
-                    req.abort();
+                const onAbort = () => {
+                    req.destroy();
                     const abortError = new Error("Request aborted");
                     abortError.name = "AbortError";
                     reject(abortError);
                 };
+                if (typeof abortSignal.addEventListener === "function") {
+                    const signal = abortSignal;
+                    signal.addEventListener("abort", onAbort, { once: true });
+                    req.once("close", () => signal.removeEventListener("abort", onAbort));
+                }
+                else {
+                    abortSignal.onabort = onAbort;
+                }
             }
+            timeouts.push(setConnectionTimeout(req, reject, this.config.connectionTimeout));
+            timeouts.push(setSocketTimeout(req, reject, this.config.requestTimeout));
             const httpAgent = nodeHttpsOptions.agent;
             if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
-                setSocketKeepAlive(req, {
+                timeouts.push(setSocketKeepAlive(req, {
                     keepAlive: httpAgent.keepAlive,
                     keepAliveMsecs: httpAgent.keepAliveMsecs,
-                });
+                }));
             }
-            writeRequestBodyPromise = writeRequestBody(req, request, this.config.requestTimeout).catch(_reject);
+            writeRequestBodyPromise = writeRequestBody(req, request, this.config.requestTimeout).catch((e) => {
+                timeouts.forEach(timing.clearTimeout);
+                return _reject(e);
+            });
         });
     }
     updateHttpClientConfig(key, value) {

package/node_modules/{@smithy → @amzn/codewhisperer-streaming/node_modules/@smithy}/node-http-handler/dist-es/node-http2-connection-manager.js

@@ -72,7 +72,7 @@ export class NodeHttp2ConnectionManager {
         }
     }
     setMaxConcurrentStreams(maxConcurrentStreams) {
-        if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) {
+        if (maxConcurrentStreams && maxConcurrentStreams <= 0) {
             throw new RangeError("maxConcurrentStreams must be greater than zero.");
         }
         this.config.maxConcurrency = maxConcurrentStreams;

package/node_modules/{@smithy → @amzn/codewhisperer-streaming/node_modules/@smithy}/node-http-handler/dist-es/node-http2-handler.js

@@ -113,12 +113,20 @@ export class NodeHttp2Handler {
                 });
             }
             if (abortSignal) {
-                abortSignal.onabort = () => {
+                const onAbort = () => {
                     req.close();
                     const abortError = new Error("Request aborted");
                     abortError.name = "AbortError";
                     rejectWithDestroy(abortError);
                 };
+                if (typeof abortSignal.addEventListener === "function") {
+                    const signal = abortSignal;
+                    signal.addEventListener("abort", onAbort, { once: true });
+                    req.once("close", () => signal.removeEventListener("abort", onAbort));
+                }
+                else {
+                    abortSignal.onabort = onAbort;
+                }
             }
             req.on("frameError", (type, code, id) => {
                 rejectWithDestroy(new Error(`Frame type id ${type} in stream id ${id} has failed with code ${code}.`));

package/node_modules/{@smithy → @amzn/codewhisperer-streaming/node_modules/@smithy}/node-http-handler/dist-es/server.mock.js

@@ -4,6 +4,7 @@ import { createServer as createHttp2Server } from "http2";
 import { createServer as createHttpsServer } from "https";
 import { join } from "path";
 import { Readable } from "stream";
+import { timing } from "./timing";
 const fixturesDir = join(__dirname, "..", "fixtures");
 const setResponseHeaders = (response, headers) => {
     for (const [key, value] of Object.entries(headers)) {
@@ -20,17 +21,23 @@ const setResponseBody = (response, body) => {
 };
 export const createResponseFunction = (httpResp) => (request, response) => {
     response.statusCode = httpResp.statusCode;
+    if (httpResp.reason) {
+        response.statusMessage = httpResp.reason;
+    }
     setResponseHeaders(response, httpResp.headers);
     setResponseBody(response, httpResp.body);
 };
 export const createResponseFunctionWithDelay = (httpResp, delay) => (request, response) => {
     response.statusCode = httpResp.statusCode;
+    if (httpResp.reason) {
+        response.statusMessage = httpResp.reason;
+    }
     setResponseHeaders(response, httpResp.headers);
-    setTimeout(() => setResponseBody(response, httpResp.body), delay);
+    timing.setTimeout(() => setResponseBody(response, httpResp.body), delay);
 };
 export const createContinueResponseFunction = (httpResp) => (request, response) => {
     response.writeContinue();
-    setTimeout(() => {
+    timing.setTimeout(() => {
         createResponseFunction(httpResp)(request, response);
     }, 100);
 };

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-es/set-connection-timeout.js

@@ -0,0 +1,36 @@
+import { timing } from "./timing";
+const DEFER_EVENT_LISTENER_TIME = 1000;
+export const setConnectionTimeout = (request, reject, timeoutInMs = 0) => {
+    if (!timeoutInMs) {
+        return -1;
+    }
+    const registerTimeout = (offset) => {
+        const timeoutId = timing.setTimeout(() => {
+            request.destroy();
+            reject(Object.assign(new Error(`Socket timed out without establishing a connection within ${timeoutInMs} ms`), {
+                name: "TimeoutError",
+            }));
+        }, timeoutInMs - offset);
+        const doWithSocket = (socket) => {
+            if (socket?.connecting) {
+                socket.on("connect", () => {
+                    timing.clearTimeout(timeoutId);
+                });
+            }
+            else {
+                timing.clearTimeout(timeoutId);
+            }
+        };
+        if (request.socket) {
+            doWithSocket(request.socket);
+        }
+        else {
+            request.on("socket", doWithSocket);
+        }
+    };
+    if (timeoutInMs < 2000) {
+        registerTimeout(0);
+        return 0;
+    }
+    return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
+};

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-es/set-socket-keep-alive.js

@@ -0,0 +1,22 @@
+import { timing } from "./timing";
+const DEFER_EVENT_LISTENER_TIME = 3000;
+export const setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME) => {
+    if (keepAlive !== true) {
+        return -1;
+    }
+    const registerListener = () => {
+        if (request.socket) {
+            request.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+        }
+        else {
+            request.on("socket", (socket) => {
+                socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+            });
+        }
+    };
+    if (deferTimeMs === 0) {
+        registerListener();
+        return 0;
+    }
+    return timing.setTimeout(registerListener, deferTimeMs);
+};

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-es/set-socket-timeout.js

@@ -0,0 +1,22 @@
+import { timing } from "./timing";
+const DEFER_EVENT_LISTENER_TIME = 3000;
+export const setSocketTimeout = (request, reject, timeoutInMs = 0) => {
+    const registerTimeout = (offset) => {
+        const timeout = timeoutInMs - offset;
+        const onTimeout = () => {
+            request.destroy();
+            reject(Object.assign(new Error(`Connection timed out after ${timeoutInMs} ms`), { name: "TimeoutError" }));
+        };
+        if (request.socket) {
+            request.socket.setTimeout(timeout, onTimeout);
+        }
+        else {
+            request.setTimeout(timeout, onTimeout);
+        }
+    };
+    if (0 < timeoutInMs && timeoutInMs < 6000) {
+        registerTimeout(0);
+        return 0;
+    }
+    return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
+};

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-es/stream-collector/index.js

@@ -0,0 +1,41 @@
+import { Collector } from "./collector";
+export const streamCollector = (stream) => {
+    if (isReadableStreamInstance(stream)) {
+        return collectReadableStream(stream);
+    }
+    return new Promise((resolve, reject) => {
+        const collector = new Collector();
+        stream.pipe(collector);
+        stream.on("error", (err) => {
+            collector.end();
+            reject(err);
+        });
+        collector.on("error", reject);
+        collector.on("finish", function () {
+            const bytes = new Uint8Array(Buffer.concat(this.bufferedBytes));
+            resolve(bytes);
+        });
+    });
+};
+const isReadableStreamInstance = (stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream;
+async function collectReadableStream(stream) {
+    const chunks = [];
+    const reader = stream.getReader();
+    let isDone = false;
+    let length = 0;
+    while (!isDone) {
+        const { done, value } = await reader.read();
+        if (value) {
+            chunks.push(value);
+            length += value.length;
+        }
+        isDone = done;
+    }
+    const collected = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        collected.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return collected;
+}

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-es/timing.js

@@ -0,0 +1,4 @@
+export const timing = {
+    setTimeout: (cb, ms) => setTimeout(cb, ms),
+    clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+};

package/node_modules/{@smithy → @amzn/codewhisperer-streaming/node_modules/@smithy}/node-http-handler/dist-es/write-request-body.js

@@ -1,29 +1,33 @@
 import { Readable } from "stream";
+import { timing } from "./timing";
 const MIN_WAIT_TIME = 1000;
 export async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME) {
     const headers = request.headers ?? {};
     const expect = headers["Expect"] || headers["expect"];
     let timeoutId = -1;
-    let hasError = false;
+    let sendBody = true;
     if (expect === "100-continue") {
-        await Promise.race([
+        sendBody = await Promise.race([
             new Promise((resolve) => {
-                timeoutId = Number(setTimeout(resolve, Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+                timeoutId = Number(timing.setTimeout(resolve, Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
             }),
             new Promise((resolve) => {
                 httpRequest.on("continue", () => {
-                    clearTimeout(timeoutId);
-                    resolve();
+                    timing.clearTimeout(timeoutId);
+                    resolve(true);
+                });
+                httpRequest.on("response", () => {
+                    timing.clearTimeout(timeoutId);
+                    resolve(false);
                 });
                 httpRequest.on("error", () => {
-                    hasError = true;
-                    clearTimeout(timeoutId);
-                    resolve();
+                    timing.clearTimeout(timeoutId);
+                    resolve(false);
                 });
             }),
         ]);
     }
-    if (!hasError) {
+    if (sendBody) {
         writeBody(httpRequest, request.body);
     }
 }

package/node_modules/{@smithy → @amzn/codewhisperer-streaming/node_modules/@smithy}/node-http-handler/dist-types/node-http-handler.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { HttpHandler, HttpRequest, HttpResponse } from "@smithy/protocol-http";
-import type { NodeHttpHandlerOptions } from "@smithy/types";
+import type { Logger, NodeHttpHandlerOptions } from "@smithy/types";
 import { HttpHandlerOptions, Provider } from "@smithy/types";
 import { Agent as hAgent } from "http";
 import { Agent as hsAgent } from "https";
@@ -23,9 +23,11 @@ export declare class NodeHttpHandler implements HttpHandler<NodeHttpHandlerOptio
      * @internal
      *
      * @param agent - http(s) agent in use by the NodeHttpHandler instance.
+     * @param socketWarningTimestamp - last socket usage check timestamp.
+     * @param logger - channel for the warning.
      * @returns timestamp of last emitted warning.
      */
-    static checkSocketUsage(agent: hAgent | hsAgent, socketWarningTimestamp: number): number;
+    static checkSocketUsage(agent: hAgent | hsAgent, socketWarningTimestamp: number, logger?: Logger): number;
     constructor(options?: NodeHttpHandlerOptions | Provider<NodeHttpHandlerOptions | void>);
     private resolveDefaultConfig;
     destroy(): void;

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-types/set-connection-timeout.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ClientRequest } from "http";
+export declare const setConnectionTimeout: (request: ClientRequest, reject: (err: Error) => void, timeoutInMs?: number) => NodeJS.Timeout | number;

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-types/set-socket-keep-alive.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ClientRequest } from "http";
+export interface SocketKeepAliveOptions {
+    keepAlive: boolean;
+    keepAliveMsecs?: number;
+}
+export declare const setSocketKeepAlive: (request: ClientRequest, { keepAlive, keepAliveMsecs }: SocketKeepAliveOptions, deferTimeMs?: number) => NodeJS.Timeout | number;

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-types/set-socket-timeout.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ClientRequest } from "http";
+export declare const setSocketTimeout: (request: ClientRequest, reject: (err: Error) => void, timeoutInMs?: number) => NodeJS.Timeout | number;

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-types/timing.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ * For test spies.
+ */
+export declare const timing: {
+    setTimeout: (cb: (...ignored: any[]) => void | unknown, ms?: number) => number;
+    clearTimeout: (timeoutId: string | number | undefined | unknown) => void;
+};

package/node_modules/{@smithy → @amzn/codewhisperer-streaming/node_modules/@smithy}/node-http-handler/dist-types/ts3.4/node-http-handler.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { HttpHandler, HttpRequest, HttpResponse } from "@smithy/protocol-http";
-import { NodeHttpHandlerOptions } from "@smithy/types";
+import { Logger, NodeHttpHandlerOptions } from "@smithy/types";
 import { HttpHandlerOptions, Provider } from "@smithy/types";
 import { Agent as hAgent } from "http";
 import { Agent as hsAgent } from "https";
@@ -22,9 +22,11 @@ export declare class NodeHttpHandler implements HttpHandler<NodeHttpHandlerOptio
      * @internal
      *
      * @param agent - http(s) agent in use by the NodeHttpHandler instance.
+     * @param socketWarningTimestamp - last socket usage check timestamp.
+     * @param logger - channel for the warning.
      * @returns timestamp of last emitted warning.
      */
-    static checkSocketUsage(agent: hAgent | hsAgent, socketWarningTimestamp: number): number;
+    static checkSocketUsage(agent: hAgent | hsAgent, socketWarningTimestamp: number, logger?: Logger): number;
     constructor(options?: NodeHttpHandlerOptions | Provider<NodeHttpHandlerOptions | void>);
     private resolveDefaultConfig;
     destroy(): void;

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-types/ts3.4/set-connection-timeout.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { ClientRequest } from "http";
+export declare const setConnectionTimeout: (request: ClientRequest, reject: (err: Error) => void, timeoutInMs?: number) => NodeJS.Timeout | number;

package/node_modules/{@smithy/node-http-handler/dist-types → @amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-types/ts3.4}/set-socket-keep-alive.d.ts

@@ -1,6 +1,7 @@
-import { ClientRequest } from "http";
-export interface SocketKeepAliveOptions {
-    keepAlive: boolean;
-    keepAliveMsecs?: number;
-}
-export declare const setSocketKeepAlive: (request: ClientRequest, { keepAlive, keepAliveMsecs }: SocketKeepAliveOptions) => void;
+/// <reference types="node" />
+import { ClientRequest } from "http";
+export interface SocketKeepAliveOptions {
+    keepAlive: boolean;
+    keepAliveMsecs?: number;
+}
+export declare const setSocketKeepAlive: (request: ClientRequest, { keepAlive, keepAliveMsecs }: SocketKeepAliveOptions, deferTimeMs?: number) => NodeJS.Timeout | number;

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-types/ts3.4/set-socket-timeout.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { ClientRequest } from "http";
+export declare const setSocketTimeout: (request: ClientRequest, reject: (err: Error) => void, timeoutInMs?: number) => NodeJS.Timeout | number;

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/node-http-handler/dist-types/ts3.4/timing.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ * For test spies.
+ */
+export declare const timing: {
+    setTimeout: (cb: (...ignored: any[]) => void | unknown, ms?: number) => number;
+    clearTimeout: (timeoutId: string | number | undefined | unknown) => void;
+};

package/node_modules/{@smithy → @amzn/codewhisperer-streaming/node_modules/@smithy}/node-http-handler/package.json

@@ -1,19 +1,20 @@
 {
   "name": "@smithy/node-http-handler",
-  "version": "2.5.0",
+  "version": "3.3.3",
   "description": "Provides a way to make requests",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'",
     "build:cjs": "node ../../scripts/inline node-http-handler",
     "build:es": "yarn g:tsc -p tsconfig.es.json",
     "build:types": "yarn g:tsc -p tsconfig.types.json",
-    "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
+    "build:types:downlevel": "rimraf dist-types/ts3.4 && downlevel-dts dist-types dist-types/ts3.4",
     "stage-release": "rimraf ./.release && yarn pack && mkdir ./.release && tar zxvf ./package.tgz --directory ./.release && rm ./package.tgz",
     "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo || exit 0",
     "lint": "eslint -c ../../.eslintrc.js \"src/**/*.ts\"",
     "format": "prettier --config ../../prettier.config.js --ignore-path ../.prettierignore --write \"**/*.{ts,md,json}\"",
     "extract:docs": "api-extractor run --local",
-    "test": "yarn g:jest --coverage --forceExit"
+    "test": "yarn g:vitest run",
+    "test:watch": "yarn g:vitest watch"
   },
   "author": {
     "name": "AWS SDK for JavaScript Team",
@@ -25,22 +26,21 @@
   "module": "./dist-es/index.js",
   "types": "./dist-types/index.d.ts",
   "dependencies": {
-    "@smithy/abort-controller": "^2.2.0",
-    "@smithy/protocol-http": "^3.3.0",
-    "@smithy/querystring-builder": "^2.2.0",
-    "@smithy/types": "^2.12.0",
+    "@smithy/abort-controller": "^3.1.9",
+    "@smithy/protocol-http": "^4.1.8",
+    "@smithy/querystring-builder": "^3.0.11",
+    "@smithy/types": "^3.7.2",
     "tslib": "^2.6.2"
   },
   "devDependencies": {
-    "@tsconfig/recommended": "1.0.1",
-    "@types/node": "^14.14.31",
+    "@types/node": "^16.18.96",
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",
     "rimraf": "3.0.2",
     "typedoc": "0.23.23"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=16.0.0"
   },
   "typesVersions": {
     "<4.0": {

package/node_modules/{@smithy/node-http-handler → @amzn/codewhisperer-streaming}/node_modules/@smithy/protocol-http/dist-cjs/index.js

@@ -24,6 +24,7 @@ __export(src_exports, {
   Fields: () => Fields,
   HttpRequest: () => HttpRequest,
   HttpResponse: () => HttpResponse,
+  IHttpRequest: () => import_types.HttpRequest,
   getHttpHandlerExtensionConfiguration: () => getHttpHandlerExtensionConfiguration,
   isValidHostname: () => isValidHostname,
   resolveHttpHandlerRuntimeConfig: () => resolveHttpHandlerRuntimeConfig
@@ -156,6 +157,7 @@ __name(_Fields, "Fields");
 var Fields = _Fields;
 
 // src/httpRequest.ts
+
 var _HttpRequest = class _HttpRequest {
   constructor(options) {
     this.method = options.method || "GET";
@@ -170,20 +172,40 @@ var _HttpRequest = class _HttpRequest {
     this.password = options.password;
     this.fragment = options.fragment;
   }
+  /**
+   * Note: this does not deep-clone the body.
+   */
+  static clone(request) {
+    const cloned = new _HttpRequest({
+      ...request,
+      headers: { ...request.headers }
+    });
+    if (cloned.query) {
+      cloned.query = cloneQuery(cloned.query);
+    }
+    return cloned;
+  }
+  /**
+   * This method only actually asserts that request is the interface {@link IHttpRequest},
+   * and not necessarily this concrete class. Left in place for API stability.
+   *
+   * Do not call instance methods on the input of this function, and
+   * do not assume it has the HttpRequest prototype.
+   */
   static isInstance(request) {
-    if (!request)
+    if (!request) {
       return false;
+    }
     const req = request;
     return "method" in req && "protocol" in req && "hostname" in req && "path" in req && typeof req["query"] === "object" && typeof req["headers"] === "object";
   }
+  /**
+   * @deprecated use static HttpRequest.clone(request) instead. It's not safe to call
+   * this method because {@link HttpRequest.isInstance} incorrectly
+   * asserts that IHttpRequest (interface) objects are of type HttpRequest (class).
+   */
   clone() {
-    const cloned = new _HttpRequest({
-      ...this,
-      headers: { ...this.headers }
-    });
-    if (cloned.query)
-      cloned.query = cloneQuery(cloned.query);
-    return cloned;
+    return _HttpRequest.clone(this);
   }
 };
 __name(_HttpRequest, "HttpRequest");

package/node_modules/{@smithy/node-http-handler → @amzn/codewhisperer-streaming}/node_modules/@smithy/protocol-http/dist-es/httpRequest.js

@@ -16,9 +16,20 @@ export class HttpRequest {
         this.password = options.password;
         this.fragment = options.fragment;
     }
+    static clone(request) {
+        const cloned = new HttpRequest({
+            ...request,
+            headers: { ...request.headers },
+        });
+        if (cloned.query) {
+            cloned.query = cloneQuery(cloned.query);
+        }
+        return cloned;
+    }
     static isInstance(request) {
-        if (!request)
+        if (!request) {
             return false;
+        }
         const req = request;
         return ("method" in req &&
             "protocol" in req &&
@@ -28,13 +39,7 @@ export class HttpRequest {
             typeof req["headers"] === "object");
     }
     clone() {
-        const cloned = new HttpRequest({
-            ...this,
-            headers: { ...this.headers },
-        });
-        if (cloned.query)
-            cloned.query = cloneQuery(cloned.query);
-        return cloned;
+        return HttpRequest.clone(this);
     }
 }
 function cloneQuery(query) {