@probelabs/probe 0.6.0-rc226 → 0.6.0-rc227

package/cjs/index.cjs

@@ -16079,8 +16079,45 @@ var require_dist_cjs29 = __commonJS({
   }
 });
 
-// node_modules/@aws-crypto/util/node_modules/@smithy/is-array-buffer/dist-cjs/index.js
+// node_modules/@aws-sdk/util-format-url/dist-cjs/index.js
 var require_dist_cjs30 = __commonJS({
+  "node_modules/@aws-sdk/util-format-url/dist-cjs/index.js"(exports2) {
+    "use strict";
+    var querystringBuilder = require_dist_cjs14();
+    function formatUrl(request) {
+      const { port, query: query2 } = request;
+      let { protocol, path: path9, hostname } = request;
+      if (protocol && protocol.slice(-1) !== ":") {
+        protocol += ":";
+      }
+      if (port) {
+        hostname += `:${port}`;
+      }
+      if (path9 && path9.charAt(0) !== "/") {
+        path9 = `/${path9}`;
+      }
+      let queryString = query2 ? querystringBuilder.buildQueryString(query2) : "";
+      if (queryString && queryString[0] !== "?") {
+        queryString = `?${queryString}`;
+      }
+      let auth = "";
+      if (request.username != null || request.password != null) {
+        const username = request.username ?? "";
+        const password = request.password ?? "";
+        auth = `${username}:${password}@`;
+      }
+      let fragment = "";
+      if (request.fragment) {
+        fragment = `#${request.fragment}`;
+      }
+      return `${protocol}//${auth}${hostname}${path9}${queryString}${fragment}`;
+    }
+    exports2.formatUrl = formatUrl;
+  }
+});
+
+// node_modules/@aws-crypto/util/node_modules/@smithy/is-array-buffer/dist-cjs/index.js
+var require_dist_cjs31 = __commonJS({
   "node_modules/@aws-crypto/util/node_modules/@smithy/is-array-buffer/dist-cjs/index.js"(exports2, module2) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -16110,7 +16147,7 @@ var require_dist_cjs30 = __commonJS({
 });
 
 // node_modules/@aws-crypto/util/node_modules/@smithy/util-buffer-from/dist-cjs/index.js
-var require_dist_cjs31 = __commonJS({
+var require_dist_cjs32 = __commonJS({
   "node_modules/@aws-crypto/util/node_modules/@smithy/util-buffer-from/dist-cjs/index.js"(exports2, module2) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -16136,7 +16173,7 @@ var require_dist_cjs31 = __commonJS({
       fromString: () => fromString
     });
     module2.exports = __toCommonJS2(src_exports);
-    var import_is_array_buffer = require_dist_cjs30();
+    var import_is_array_buffer = require_dist_cjs31();
     var import_buffer = require("buffer");
     var fromArrayBuffer = /* @__PURE__ */ __name((input, offset = 0, length = input.byteLength - offset) => {
       if (!(0, import_is_array_buffer.isArrayBuffer)(input)) {
@@ -16154,7 +16191,7 @@ var require_dist_cjs31 = __commonJS({
 });
 
 // node_modules/@aws-crypto/util/node_modules/@smithy/util-utf8/dist-cjs/index.js
-var require_dist_cjs32 = __commonJS({
+var require_dist_cjs33 = __commonJS({
   "node_modules/@aws-crypto/util/node_modules/@smithy/util-utf8/dist-cjs/index.js"(exports2, module2) {
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -16181,7 +16218,7 @@ var require_dist_cjs32 = __commonJS({
       toUtf8: () => toUtf811
     });
     module2.exports = __toCommonJS2(src_exports);
-    var import_util_buffer_from = require_dist_cjs31();
+    var import_util_buffer_from = require_dist_cjs32();
     var fromUtf88 = /* @__PURE__ */ __name((input) => {
       const buf = (0, import_util_buffer_from.fromString)(input, "utf8");
       return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
@@ -16213,7 +16250,7 @@ var require_convertToBuffer = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.convertToBuffer = void 0;
-    var util_utf8_1 = require_dist_cjs32();
+    var util_utf8_1 = require_dist_cjs33();
     var fromUtf88 = typeof Buffer !== "undefined" && Buffer.from ? function(input) {
       return Buffer.from(input, "utf8");
     } : util_utf8_1.fromUtf8;
@@ -16660,7 +16697,7 @@ var require_main3 = __commonJS({
 });
 
 // node_modules/@smithy/eventstream-codec/dist-cjs/index.js
-var require_dist_cjs33 = __commonJS({
+var require_dist_cjs34 = __commonJS({
   "node_modules/@smithy/eventstream-codec/dist-cjs/index.js"(exports2) {
     "use strict";
     var crc32 = require_main3();
@@ -17043,48 +17080,11 @@ var require_dist_cjs33 = __commonJS({
   }
 });
 
-// node_modules/@aws-sdk/util-format-url/dist-cjs/index.js
-var require_dist_cjs34 = __commonJS({
-  "node_modules/@aws-sdk/util-format-url/dist-cjs/index.js"(exports2) {
-    "use strict";
-    var querystringBuilder = require_dist_cjs14();
-    function formatUrl(request) {
-      const { port, query: query2 } = request;
-      let { protocol, path: path9, hostname } = request;
-      if (protocol && protocol.slice(-1) !== ":") {
-        protocol += ":";
-      }
-      if (port) {
-        hostname += `:${port}`;
-      }
-      if (path9 && path9.charAt(0) !== "/") {
-        path9 = `/${path9}`;
-      }
-      let queryString = query2 ? querystringBuilder.buildQueryString(query2) : "";
-      if (queryString && queryString[0] !== "?") {
-        queryString = `?${queryString}`;
-      }
-      let auth = "";
-      if (request.username != null || request.password != null) {
-        const username = request.username ?? "";
-        const password = request.password ?? "";
-        auth = `${username}:${password}@`;
-      }
-      let fragment = "";
-      if (request.fragment) {
-        fragment = `#${request.fragment}`;
-      }
-      return `${protocol}//${auth}${hostname}${path9}${queryString}${fragment}`;
-    }
-    exports2.formatUrl = formatUrl;
-  }
-});
-
 // node_modules/@smithy/eventstream-serde-universal/dist-cjs/index.js
 var require_dist_cjs35 = __commonJS({
   "node_modules/@smithy/eventstream-serde-universal/dist-cjs/index.js"(exports2) {
     "use strict";
-    var eventstreamCodec = require_dist_cjs33();
+    var eventstreamCodec = require_dist_cjs34();
     function getChunkedStream(source) {
       let currentMessageTotalLength = 0;
       let currentMessagePendingLength = 0;
@@ -17269,183 +17269,20 @@ var require_dist_cjs36 = __commonJS({
 var require_dist_cjs37 = __commonJS({
   "node_modules/@aws-sdk/middleware-websocket/dist-cjs/index.js"(exports2) {
     "use strict";
-    var eventstreamCodec = require_dist_cjs33();
-    var utilHexEncoding = require_dist_cjs17();
-    var protocolHttp = require_dist_cjs2();
-    var utilFormatUrl = require_dist_cjs34();
+    var utilFormatUrl = require_dist_cjs30();
     var eventstreamSerdeBrowser = require_dist_cjs36();
     var fetchHttpHandler = require_dist_cjs16();
-    var getEventSigningTransformStream = (initialSignature, messageSigner, eventStreamCodec, systemClockOffsetProvider) => {
-      let priorSignature = initialSignature;
-      const transformer = {
-        start() {
-        },
-        async transform(chunk, controller) {
-          try {
-            const now = new Date(Date.now() + await systemClockOffsetProvider());
-            const dateHeader = {
-              ":date": { type: "timestamp", value: now }
-            };
-            const signedMessage = await messageSigner.sign({
-              message: {
-                body: chunk,
-                headers: dateHeader
-              },
-              priorSignature
-            }, {
-              signingDate: now
-            });
-            priorSignature = signedMessage.signature;
-            const serializedSigned = eventStreamCodec.encode({
-              headers: {
-                ...dateHeader,
-                ":chunk-signature": {
-                  type: "binary",
-                  value: utilHexEncoding.fromHex(signedMessage.signature)
-                }
-              },
-              body: chunk
-            });
-            controller.enqueue(serializedSigned);
-          } catch (error2) {
-            controller.error(error2);
-          }
-        }
-      };
-      return new TransformStream({ ...transformer });
-    };
-    var EventStreamPayloadHandler = class {
-      messageSigner;
-      eventStreamCodec;
-      systemClockOffsetProvider;
-      constructor(options) {
-        this.messageSigner = options.messageSigner;
-        this.eventStreamCodec = new eventstreamCodec.EventStreamCodec(options.utf8Encoder, options.utf8Decoder);
-        this.systemClockOffsetProvider = async () => options.systemClockOffset ?? 0;
-      }
-      async handle(next, args, context = {}) {
-        const request = args.request;
-        const { body: payload2, headers, query: query2 } = request;
-        if (!(payload2 instanceof ReadableStream)) {
-          throw new Error("Eventstream payload must be a ReadableStream.");
-        }
-        const placeHolderStream = new TransformStream();
-        request.body = placeHolderStream.readable;
-        const match2 = (headers?.authorization ?? "").match(/Signature=(\w+)$/);
-        const priorSignature = (match2 ?? [])[1] ?? (query2 && query2["X-Amz-Signature"]) ?? "";
-        const signingStream = getEventSigningTransformStream(priorSignature, await this.messageSigner(), this.eventStreamCodec, this.systemClockOffsetProvider);
-        payload2.pipeThrough(signingStream).pipeThrough(placeHolderStream);
-        let result;
-        try {
-          result = await next(args);
-        } catch (e5) {
-          const p5 = payload2.cancel?.();
-          if (p5 instanceof Promise) {
-            p5.catch(() => {
-            });
-          }
-          throw e5;
-        }
-        return result;
-      }
-    };
-    var eventStreamPayloadHandlerProvider = (options) => new EventStreamPayloadHandler(options);
-    var injectSessionIdMiddleware = () => (next) => async (args) => {
-      const requestParams = {
-        ...args.input
-      };
-      const response = await next(args);
-      const output = response.output;
-      if (requestParams.SessionId && output.SessionId == null) {
-        output.SessionId = requestParams.SessionId;
-      }
-      return response;
-    };
-    var injectSessionIdMiddlewareOptions = {
-      step: "initialize",
-      name: "injectSessionIdMiddleware",
-      tags: ["WEBSOCKET", "EVENT_STREAM"],
-      override: true
-    };
-    var websocketEndpointMiddleware = (config, options) => (next) => (args) => {
-      const { request } = args;
-      if (protocolHttp.HttpRequest.isInstance(request) && config.requestHandler.metadata?.handlerProtocol?.toLowerCase().includes("websocket")) {
-        request.protocol = "wss:";
-        request.method = "GET";
-        request.path = `${request.path}-websocket`;
-        const { headers } = request;
-        delete headers["content-type"];
-        delete headers["x-amz-content-sha256"];
-        for (const name14 of Object.keys(headers)) {
-          if (name14.indexOf(options.headerPrefix) === 0) {
-            const chunkedName = name14.replace(options.headerPrefix, "");
-            request.query[chunkedName] = headers[name14];
-          }
-        }
-        if (headers["x-amz-user-agent"]) {
-          request.query["user-agent"] = headers["x-amz-user-agent"];
-        }
-        request.headers = { host: headers.host ?? request.hostname };
-      }
-      return next(args);
-    };
-    var websocketEndpointMiddlewareOptions = {
-      name: "websocketEndpointMiddleware",
-      tags: ["WEBSOCKET", "EVENT_STREAM"],
-      relation: "after",
-      toMiddleware: "eventStreamHeaderMiddleware",
-      override: true
-    };
-    var getWebSocketPlugin = (config, options) => ({
-      applyToStack: (clientStack) => {
-        clientStack.addRelativeTo(websocketEndpointMiddleware(config, options), websocketEndpointMiddlewareOptions);
-        clientStack.add(injectSessionIdMiddleware(), injectSessionIdMiddlewareOptions);
-      }
-    });
+    var protocolHttp = require_dist_cjs2();
+    var utilBase64 = require_dist_cjs12();
+    var eventstreamCodec = require_dist_cjs34();
+    var utilHexEncoding = require_dist_cjs17();
     var isWebSocketRequest = (request) => request.protocol === "ws:" || request.protocol === "wss:";
-    var WebsocketSignatureV4 = class {
-      signer;
-      constructor(options) {
-        this.signer = options.signer;
-      }
-      presign(originalRequest, options = {}) {
-        return this.signer.presign(originalRequest, options);
-      }
-      async sign(toSign, options) {
-        if (protocolHttp.HttpRequest.isInstance(toSign) && isWebSocketRequest(toSign)) {
-          const signedRequest = await this.signer.presign({ ...toSign, body: "" }, {
-            ...options,
-            expiresIn: 60,
-            unsignableHeaders: new Set(Object.keys(toSign.headers).filter((header) => header !== "host"))
-          });
-          return {
-            ...signedRequest,
-            body: toSign.body
-          };
-        } else {
-          return this.signer.sign(toSign, options);
-        }
-      }
-    };
-    var resolveWebSocketConfig = (input) => {
-      const { signer } = input;
-      return Object.assign(input, {
-        signer: async (authScheme) => {
-          const signerObj = await signer(authScheme);
-          if (validateSigner(signerObj)) {
-            return new WebsocketSignatureV4({ signer: signerObj });
-          }
-          throw new Error("Expected WebsocketSignatureV4 signer, please check the client constructor.");
-        }
-      });
-    };
-    var validateSigner = (signer) => !!signer;
-    var DEFAULT_WS_CONNECTION_TIMEOUT_MS = 2e3;
+    var DEFAULT_WS_CONNECTION_TIMEOUT_MS = 3e3;
     var WebSocketFetchHandler = class _WebSocketFetchHandler {
       metadata = {
         handlerProtocol: "websocket/h1.1"
       };
-      config;
+      config = {};
       configPromise;
       httpHandler;
       sockets = {};
@@ -17457,12 +17294,19 @@ var require_dist_cjs37 = __commonJS({
       }
       constructor(options, httpHandler = new fetchHttpHandler.FetchHttpHandler()) {
         this.httpHandler = httpHandler;
+        const setConfig = (opts) => {
+          this.config = {
+            ...opts ?? {}
+          };
+          return this.config;
+        };
         if (typeof options === "function") {
           this.config = {};
-          this.configPromise = options().then((opts) => this.config = opts ?? {});
+          this.configPromise = options().then((opts) => {
+            return setConfig(opts);
+          });
         } else {
-          this.config = options ?? {};
-          this.configPromise = Promise.resolve(this.config);
+          this.configPromise = Promise.resolve(setConfig(options));
         }
       }
       destroy() {
@@ -17474,17 +17318,20 @@ var require_dist_cjs37 = __commonJS({
         }
       }
       async handle(request) {
+        this.config = await this.configPromise;
+        const { logger: logger2 } = this.config;
         if (!isWebSocketRequest(request)) {
+          logger2?.debug?.(`@aws-sdk - ws fetching ${request.protocol}${request.hostname}${request.path}`);
           return this.httpHandler.handle(request);
         }
         const url = utilFormatUrl.formatUrl(request);
+        logger2?.debug?.(`@aws-sdk - ws connecting ${url.split("?")[0]}`);
         const socket = new WebSocket(url);
         if (!this.sockets[url]) {
           this.sockets[url] = [];
         }
         this.sockets[url].push(socket);
         socket.binaryType = "arraybuffer";
-        this.config = await this.configPromise;
         const { connectionTimeout = DEFAULT_WS_CONNECTION_TIMEOUT_MS } = this.config;
         await this.waitForReady(socket, connectionTimeout);
         const { body } = request;
@@ -17516,7 +17363,8 @@ var require_dist_cjs37 = __commonJS({
             this.removeNotUsableSockets(socket.url);
             reject2({
               $metadata: {
-                httpStatusCode: 500
+                httpStatusCode: 500,
+                websocketSynthetic500Error: true
               }
             });
           }, connectionTimeout);
@@ -17527,42 +17375,57 @@ var require_dist_cjs37 = __commonJS({
         });
       }
       connect(socket, data2) {
-        let streamError = void 0;
-        let socketErrorOccurred = false;
-        let reject2 = () => {
-        };
-        let resolve7 = () => {
+        const messageQueue = [];
+        let pendingResolve = null;
+        let pendingReject = null;
+        const push = (item) => {
+          if (pendingResolve) {
+            if (item.error) {
+              pendingReject(item.error);
+            } else {
+              pendingResolve({ done: item.done, value: item.value });
+            }
+            pendingResolve = null;
+            pendingReject = null;
+          } else {
+            messageQueue.push(item);
+          }
         };
         socket.onmessage = (event) => {
-          resolve7({
-            done: false,
-            value: new Uint8Array(event.data)
-          });
+          const { data: data3 } = event;
+          if (typeof data3 === "string") {
+            push({
+              done: false,
+              value: utilBase64.fromBase64(data3)
+            });
+          } else {
+            push({
+              done: false,
+              value: new Uint8Array(data3)
+            });
+          }
         };
-        socket.onerror = (error2) => {
-          socketErrorOccurred = true;
+        socket.onerror = (event) => {
           socket.close();
-          reject2(error2);
+          push({ done: true, error: event });
         };
         socket.onclose = () => {
           this.removeNotUsableSockets(socket.url);
-          if (socketErrorOccurred)
-            return;
-          if (streamError) {
-            reject2(streamError);
-          } else {
-            resolve7({
-              done: true,
-              value: void 0
-            });
-          }
+          push({ done: true });
         };
         const outputStream = {
           [Symbol.asyncIterator]: () => ({
-            next: () => {
-              return new Promise((_resolve, _reject) => {
-                resolve7 = _resolve;
-                reject2 = _reject;
+            async next() {
+              if (messageQueue.length > 0) {
+                const item = messageQueue.shift();
+                if (item.error) {
+                  throw item.error;
+                }
+                return { done: item.done, value: item.value };
+              }
+              return new Promise((resolve7, reject2) => {
+                pendingResolve = resolve7;
+                pendingReject = reject2;
               });
             }
           })
@@ -17577,7 +17440,10 @@ var require_dist_cjs37 = __commonJS({
               }
             }
           } catch (err) {
-            streamError = err;
+            push({
+              done: true,
+              error: err
+            });
           } finally {
             socket.close(1e3);
           }
@@ -17601,6 +17467,174 @@ var require_dist_cjs37 = __commonJS({
     };
     var toReadableStream = (asyncIterable) => typeof ReadableStream === "function" ? eventstreamSerdeBrowser.iterableToReadableStream(asyncIterable) : asyncIterable;
     var isReadableStream = (payload2) => typeof ReadableStream === "function" && payload2 instanceof ReadableStream;
+    var websocketEndpointMiddleware = (config, options) => (next) => (args) => {
+      const { request } = args;
+      if (protocolHttp.HttpRequest.isInstance(request) && config.requestHandler.metadata?.handlerProtocol?.toLowerCase().includes("websocket")) {
+        request.protocol = "wss:";
+        request.method = "GET";
+        request.path = `${request.path}-websocket`;
+        const { headers } = request;
+        delete headers["content-type"];
+        delete headers["x-amz-content-sha256"];
+        for (const name14 of Object.keys(headers)) {
+          if (name14.indexOf(options.headerPrefix) === 0) {
+            const chunkedName = name14.replace(options.headerPrefix, "");
+            request.query[chunkedName] = headers[name14];
+          }
+        }
+        if (headers["x-amz-user-agent"]) {
+          request.query["user-agent"] = headers["x-amz-user-agent"];
+        }
+        request.headers = { host: headers.host ?? request.hostname };
+      }
+      return next(args);
+    };
+    var websocketEndpointMiddlewareOptions = {
+      name: "websocketEndpointMiddleware",
+      tags: ["WEBSOCKET", "EVENT_STREAM"],
+      relation: "after",
+      toMiddleware: "eventStreamHeaderMiddleware",
+      override: true
+    };
+    var injectSessionIdMiddleware = () => (next) => async (args) => {
+      const requestParams = {
+        ...args.input
+      };
+      const response = await next(args);
+      const output = response.output;
+      if (requestParams.SessionId && output.SessionId == null) {
+        output.SessionId = requestParams.SessionId;
+      }
+      return response;
+    };
+    var injectSessionIdMiddlewareOptions = {
+      step: "initialize",
+      name: "injectSessionIdMiddleware",
+      tags: ["WEBSOCKET", "EVENT_STREAM"],
+      override: true
+    };
+    var getWebSocketPlugin = (config, options) => ({
+      applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(websocketEndpointMiddleware(config, options), websocketEndpointMiddlewareOptions);
+        clientStack.add(injectSessionIdMiddleware(), injectSessionIdMiddlewareOptions);
+      }
+    });
+    var WebsocketSignatureV4 = class {
+      signer;
+      constructor(options) {
+        this.signer = options.signer;
+      }
+      presign(originalRequest, options = {}) {
+        return this.signer.presign(originalRequest, options);
+      }
+      async sign(toSign, options) {
+        if (protocolHttp.HttpRequest.isInstance(toSign) && isWebSocketRequest(toSign)) {
+          const signedRequest = await this.signer.presign({ ...toSign, body: "" }, {
+            ...options,
+            expiresIn: 60,
+            unsignableHeaders: new Set(Object.keys(toSign.headers).filter((header) => header !== "host"))
+          });
+          return {
+            ...signedRequest,
+            body: toSign.body
+          };
+        } else {
+          return this.signer.sign(toSign, options);
+        }
+      }
+      signMessage(message, args) {
+        return this.signer.signMessage(message, args);
+      }
+    };
+    var resolveWebSocketConfig = (input) => {
+      const { signer } = input;
+      return Object.assign(input, {
+        signer: async (authScheme) => {
+          const signerObj = await signer(authScheme);
+          if (validateSigner(signerObj)) {
+            return new WebsocketSignatureV4({ signer: signerObj });
+          }
+          throw new Error("Expected WebsocketSignatureV4 signer, please check the client constructor.");
+        }
+      });
+    };
+    var validateSigner = (signer) => !!signer;
+    var EventSigningTransformStream = class extends TransformStream {
+      constructor(initialSignature, messageSigner, eventStreamCodec, systemClockOffsetProvider) {
+        let priorSignature = initialSignature;
+        super({
+          start() {
+          },
+          async transform(chunk, controller) {
+            try {
+              const now = new Date(Date.now() + await systemClockOffsetProvider());
+              const dateHeader = {
+                ":date": { type: "timestamp", value: now }
+              };
+              const signedMessage = await messageSigner.sign({
+                message: {
+                  body: chunk,
+                  headers: dateHeader
+                },
+                priorSignature
+              }, {
+                signingDate: now
+              });
+              priorSignature = signedMessage.signature;
+              const serializedSigned = eventStreamCodec.encode({
+                headers: {
+                  ...dateHeader,
+                  ":chunk-signature": {
+                    type: "binary",
+                    value: utilHexEncoding.fromHex(signedMessage.signature)
+                  }
+                },
+                body: chunk
+              });
+              controller.enqueue(serializedSigned);
+            } catch (error2) {
+              controller.error(error2);
+            }
+          }
+        });
+      }
+    };
+    var EventStreamPayloadHandler = class {
+      messageSigner;
+      eventStreamCodec;
+      systemClockOffsetProvider;
+      constructor(options) {
+        this.messageSigner = options.messageSigner;
+        this.eventStreamCodec = new eventstreamCodec.EventStreamCodec(options.utf8Encoder, options.utf8Decoder);
+        this.systemClockOffsetProvider = async () => options.systemClockOffset ?? 0;
+      }
+      async handle(next, args, context = {}) {
+        const request = args.request;
+        const { body: payload2, headers, query: query2 } = request;
+        if (!(payload2 instanceof ReadableStream)) {
+          throw new Error("Eventstream payload must be a ReadableStream.");
+        }
+        const placeHolderStream = new TransformStream();
+        request.body = placeHolderStream.readable;
+        const match2 = (headers?.authorization ?? "").match(/Signature=(\w+)$/);
+        const priorSignature = (match2 ?? [])[1] ?? (query2 && query2["X-Amz-Signature"]) ?? "";
+        const signingStream = new EventSigningTransformStream(priorSignature, await this.messageSigner(), this.eventStreamCodec, this.systemClockOffsetProvider);
+        payload2.pipeThrough(signingStream).pipeThrough(placeHolderStream);
+        let result;
+        try {
+          result = await next(args);
+        } catch (e5) {
+          const p5 = payload2.cancel?.();
+          if (p5 instanceof Promise) {
+            p5.catch(() => {
+            });
+          }
+          throw e5;
+        }
+        return result;
+      }
+    };
+    var eventStreamPayloadHandlerProvider = (options) => new EventStreamPayloadHandler(options);
     exports2.WebSocketFetchHandler = WebSocketFetchHandler;
     exports2.eventStreamPayloadHandlerProvider = eventStreamPayloadHandlerProvider;
     exports2.getWebSocketPlugin = getWebSocketPlugin;
@@ -19248,7 +19282,7 @@ var require_package2 = __commonJS({
     module2.exports = {
       name: "@aws-sdk/client-bedrock-runtime",
       description: "AWS SDK for JavaScript Bedrock Runtime Client for Node.js, Browser and React Native",
-      version: "3.983.0",
+      version: "3.984.0",
       scripts: {
         build: "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
         "build:cjs": "node ../../scripts/compilation/inline client-bedrock-runtime",
@@ -19270,17 +19304,17 @@ var require_package2 = __commonJS({
         "@aws-crypto/sha256-js": "5.2.0",
         "@aws-sdk/core": "^3.973.6",
         "@aws-sdk/credential-provider-node": "^3.972.5",
-        "@aws-sdk/eventstream-handler-node": "^3.972.4",
+        "@aws-sdk/eventstream-handler-node": "^3.972.5",
         "@aws-sdk/middleware-eventstream": "^3.972.3",
         "@aws-sdk/middleware-host-header": "^3.972.3",
         "@aws-sdk/middleware-logger": "^3.972.3",
         "@aws-sdk/middleware-recursion-detection": "^3.972.3",
         "@aws-sdk/middleware-user-agent": "^3.972.6",
-        "@aws-sdk/middleware-websocket": "^3.972.4",
+        "@aws-sdk/middleware-websocket": "^3.972.5",
         "@aws-sdk/region-config-resolver": "^3.972.3",
-        "@aws-sdk/token-providers": "3.983.0",
+        "@aws-sdk/token-providers": "3.984.0",
         "@aws-sdk/types": "^3.973.1",
-        "@aws-sdk/util-endpoints": "3.983.0",
+        "@aws-sdk/util-endpoints": "3.984.0",
         "@aws-sdk/util-user-agent-browser": "^3.972.3",
         "@aws-sdk/util-user-agent-node": "^3.972.4",
         "@smithy/config-resolver": "^4.4.6",
@@ -25592,9 +25626,9 @@ var require_dist_cjs65 = __commonJS({
 var require_dist_cjs66 = __commonJS({
   "node_modules/@aws-sdk/eventstream-handler-node/dist-cjs/index.js"(exports2) {
     "use strict";
-    var eventstreamCodec = require_dist_cjs33();
-    var stream2 = require("stream");
-    var EventSigningStream = class extends stream2.Transform {
+    var eventstreamCodec = require_dist_cjs34();
+    var node_stream = require("node:stream");
+    var EventSigningTransformStream = class extends node_stream.Transform {
       priorSignature;
       messageSigner;
       eventStreamCodec;
@@ -25660,16 +25694,16 @@ var require_dist_cjs66 = __commonJS({
       async handle(next, args, context = {}) {
         const request = args.request;
         const { body: payload2, query: query2 } = request;
-        if (!(payload2 instanceof stream2.Readable)) {
+        if (!(payload2 instanceof node_stream.Readable)) {
           throw new Error("Eventstream payload must be a Readable stream.");
         }
         const payloadStream = payload2;
-        request.body = new stream2.PassThrough({
+        request.body = new node_stream.PassThrough({
           objectMode: true
         });
         const match2 = request.headers?.authorization?.match(/Signature=([\w]+)$/);
         const priorSignature = match2?.[1] ?? query2?.["X-Amz-Signature"] ?? "";
-        const signingStream = new EventSigningStream({
+        const signingStream = new EventSigningTransformStream({
           priorSignature,
           eventStreamCodec: this.eventStreamCodec,
           messageSigner: await this.messageSigner(),
@@ -25678,7 +25712,7 @@ var require_dist_cjs66 = __commonJS({
         let resolvePipeline;
         const pipelineError = new Promise((resolve7, reject2) => {
           resolvePipeline = () => resolve7(void 0);
-          stream2.pipeline(payloadStream, signingStream, request.body, (err) => {
+          node_stream.pipeline(payloadStream, signingStream, request.body, (err) => {
             if (err) {
               reject2(new Error(`Pipeline error in @aws-sdk/eventstream-handler-node: ${err.message}`, { cause: err }));
             }
@@ -25783,7 +25817,7 @@ var init_package2 = __esm({
   "node_modules/@aws-sdk/token-providers/node_modules/@aws-sdk/nested-clients/package.json"() {
     package_default2 = {
       name: "@aws-sdk/nested-clients",
-      version: "3.983.0",
+      version: "3.984.0",
       description: "Nested clients for AWS SDK packages.",
       main: "./dist-cjs/index.js",
       module: "./dist-es/index.js",
@@ -25819,7 +25853,7 @@ var init_package2 = __esm({
         "@aws-sdk/middleware-user-agent": "^3.972.6",
         "@aws-sdk/region-config-resolver": "^3.972.3",
         "@aws-sdk/types": "^3.973.1",
-        "@aws-sdk/util-endpoints": "3.983.0",
+        "@aws-sdk/util-endpoints": "3.984.0",
         "@aws-sdk/util-user-agent-browser": "^3.972.3",
         "@aws-sdk/util-user-agent-node": "^3.972.4",
         "@smithy/config-resolver": "^4.4.6",
@@ -95131,7 +95165,7 @@ __export(enhanced_claude_code_exports, {
   createEnhancedClaudeCLIEngine: () => createEnhancedClaudeCLIEngine
 });
 async function createEnhancedClaudeCLIEngine(options = {}) {
-  const { agent, systemPrompt, customPrompt, debug, sessionId, allowedTools } = options;
+  const { agent, systemPrompt, customPrompt, debug, sessionId, allowedTools, timeout = 12e4 } = options;
   const session = new Session(
     sessionId || (0, import_crypto6.randomBytes)(8).toString("hex"),
     debug
@@ -95230,6 +95264,30 @@ ${opts.schema}`;
         stdio: ["ignore", "pipe", "pipe"]
         // Ignore stdin since echo handles it
       });
+      let killed = false;
+      let timeoutHandle;
+      let sigkillHandle;
+      if (timeout > 0) {
+        timeoutHandle = setTimeout(() => {
+          if (!killed) {
+            killed = true;
+            processEnded = true;
+            proc2.kill("SIGTERM");
+            if (debug) {
+              console.log(`[DEBUG] Process timed out after ${timeout}ms, sending SIGTERM`);
+            }
+            sigkillHandle = setTimeout(() => {
+              if (proc2.exitCode === null) {
+                proc2.kill("SIGKILL");
+                if (debug) {
+                  console.log("[DEBUG] Process did not exit, sending SIGKILL");
+                }
+              }
+            }, 5e3);
+            emitter.emit("error", new Error(`Claude CLI process timed out after ${timeout}ms`));
+          }
+        }, timeout);
+      }
       proc2.stdout.on("data", (data2) => {
         buffer += data2.toString();
         processJsonBuffer(buffer, emitter, session, debug, toolCollector);
@@ -95246,10 +95304,20 @@ ${opts.schema}`;
         }
       });
       proc2.on("close", (code) => {
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+        if (sigkillHandle) {
+          clearTimeout(sigkillHandle);
+        }
         processEnded = true;
         if (code !== 0 && debug) {
           console.log(`[DEBUG] Process exited with code ${code}`);
         }
+        if (killed) {
+          emitter.emit("end");
+          return;
+        }
         if (buffer.trim()) {
           processJsonBuffer(buffer, emitter, session, debug, toolCollector);
         }
@@ -95265,6 +95333,13 @@ ${opts.schema}`;
         emitter.emit("end");
       });
       proc2.on("error", (error2) => {
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+        if (sigkillHandle) {
+          clearTimeout(sigkillHandle);
+        }
+        processEnded = true;
         emitter.emit("error", error2);
       });
       const messageQueue = [];
@@ -95310,7 +95385,22 @@ ${opts.schema}`;
 \u{1F527} Using ${msg.name}: ${JSON.stringify(msg.input)}
 `
             };
-            const result = await executeProbleTool(agent, msg.name, msg.input);
+            const toolTimeout = 3e4;
+            let toolTimeoutId;
+            const timeoutPromise = new Promise((_, reject2) => {
+              toolTimeoutId = setTimeout(() => reject2(new Error(`Tool ${msg.name} timed out after ${toolTimeout}ms`)), toolTimeout);
+            });
+            let result;
+            try {
+              result = await Promise.race([
+                executeProbleTool(agent, msg.name, msg.input),
+                timeoutPromise
+              ]);
+            } catch (error2) {
+              result = `Tool error: ${error2.message}`;
+            } finally {
+              clearTimeout(toolTimeoutId);
+            }
             yield { type: "text", content: `${result}
 ` };
           } else if (msg.type === "toolBatch") {
@@ -95886,6 +95976,9 @@ var init_enhanced_vercel = __esm({
 // src/agent/ProbeAgent.js
 var ProbeAgent_exports = {};
 __export(ProbeAgent_exports, {
+  ENGINE_ACTIVITY_TIMEOUT_DEFAULT: () => ENGINE_ACTIVITY_TIMEOUT_DEFAULT,
+  ENGINE_ACTIVITY_TIMEOUT_MAX: () => ENGINE_ACTIVITY_TIMEOUT_MAX,
+  ENGINE_ACTIVITY_TIMEOUT_MIN: () => ENGINE_ACTIVITY_TIMEOUT_MIN,
   ProbeAgent: () => ProbeAgent
 });
 function extractWrappedToolName(wrappedToolError) {
@@ -95909,7 +96002,7 @@ Your content here
 
 Do NOT wrap in other tags like <api_call>, <tool_name>, <function>, etc.`;
 }
-var import_dotenv, import_anthropic2, import_openai2, import_google2, import_ai3, import_crypto8, import_events4, import_fs11, import_promises6, import_path13, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
+var import_dotenv, import_anthropic2, import_openai2, import_google2, import_ai3, import_crypto8, import_events4, import_fs11, import_promises6, import_path13, ENGINE_ACTIVITY_TIMEOUT_DEFAULT, ENGINE_ACTIVITY_TIMEOUT_MIN, ENGINE_ACTIVITY_TIMEOUT_MAX, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
     "use strict";
@@ -95949,6 +96042,9 @@ var init_ProbeAgent = __esm({
     init_delegate();
     init_tasks();
     import_dotenv.default.config();
+    ENGINE_ACTIVITY_TIMEOUT_DEFAULT = 18e4;
+    ENGINE_ACTIVITY_TIMEOUT_MIN = 5e3;
+    ENGINE_ACTIVITY_TIMEOUT_MAX = 6e5;
     MAX_TOOL_ITERATIONS = (() => {
       const val = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
       if (isNaN(val) || val < 1 || val > 200) {
@@ -96007,6 +96103,8 @@ var init_ProbeAgent = __esm({
        * @param {number} [options.fallback.maxTotalAttempts=10] - Maximum total attempts across all providers
        * @param {string} [options.completionPrompt] - Custom prompt to run after attempt_completion for validation/review (runs before mermaid/JSON validation)
        * @param {number} [options.maxOutputTokens] - Maximum tokens for tool output before truncation (default: 20000, can also be set via PROBE_MAX_OUTPUT_TOKENS env var)
+       * @param {number} [options.requestTimeout] - Timeout in ms for AI requests (default: 120000 or REQUEST_TIMEOUT env var). Used to abort hung requests.
+       * @param {number} [options.maxOperationTimeout] - Maximum timeout in ms for the entire operation including all retries and fallbacks (default: 300000 or MAX_OPERATION_TIMEOUT env var). This is the absolute maximum time for streamTextWithRetryAndFallback.
        */
       constructor(options = {}) {
         this.sessionId = options.sessionId || (0, import_crypto8.randomUUID)();
@@ -96092,6 +96190,32 @@ var init_ProbeAgent = __esm({
         this.enableTasks = !!options.enableTasks;
         this.taskManager = null;
         this.delegationManager = new DelegationManager();
+        this.requestTimeout = options.requestTimeout ?? (() => {
+          if (process.env.REQUEST_TIMEOUT) {
+            const parsed = parseInt(process.env.REQUEST_TIMEOUT, 10);
+            if (isNaN(parsed) || parsed < 1e3 || parsed > 36e5) {
+              return 12e4;
+            }
+            return parsed;
+          }
+          return 12e4;
+        })();
+        if (this.debug) {
+          console.log(`[DEBUG] Request timeout: ${this.requestTimeout}ms`);
+        }
+        this.maxOperationTimeout = options.maxOperationTimeout ?? (() => {
+          if (process.env.MAX_OPERATION_TIMEOUT) {
+            const parsed = parseInt(process.env.MAX_OPERATION_TIMEOUT, 10);
+            if (isNaN(parsed) || parsed < 1e3 || parsed > 72e5) {
+              return 3e5;
+            }
+            return parsed;
+          }
+          return 3e5;
+        })();
+        if (this.debug) {
+          console.log(`[DEBUG] Max operation timeout: ${this.maxOperationTimeout}ms`);
+        }
         this.retryConfig = options.retry || {};
         this.retryManager = null;
         this.fallbackConfig = options.fallback || null;
@@ -96711,88 +96835,98 @@ var init_ProbeAgent = __esm({
         }
       }
       /**
-       * Execute streamText with retry and fallback support
-       * @param {Object} options - streamText options
-       * @returns {Promise<Object>} - streamText result
+       * Create a streamText-compatible result from an engine stream with timeout handling
+       * @param {AsyncGenerator} engineStream - The engine's query result
+       * @param {AbortSignal} abortSignal - Signal for aborting the operation
+       * @param {number} requestTimeout - Per-request timeout in ms
+       * @param {Object} timeoutState - Object with timeoutId property (mutable for cleanup)
+       * @returns {Object} - streamText-compatible result with textStream
        * @private
        */
-      async streamTextWithRetryAndFallback(options) {
-        if (this.clientApiProvider === "claude-code" || process.env.USE_CLAUDE_CODE === "true") {
+      _createEngineTextStreamResult(engineStream, abortSignal, requestTimeout, timeoutState) {
+        const activityTimeout = (() => {
+          const parsed = parseInt(process.env.ENGINE_ACTIVITY_TIMEOUT, 10);
+          return isNaN(parsed) || parsed < ENGINE_ACTIVITY_TIMEOUT_MIN || parsed > ENGINE_ACTIVITY_TIMEOUT_MAX ? ENGINE_ACTIVITY_TIMEOUT_DEFAULT : parsed;
+        })();
+        const startTime = Date.now();
+        async function* createTextStream() {
+          let lastActivity = Date.now();
           try {
-            const engine = await this.getEngine();
-            if (engine && engine.query) {
-              const userMessages = options.messages.filter(
-                (m5) => m5.role === "user" && !m5.content.includes("WARNING: You have reached the maximum tool iterations limit")
-              );
-              const lastUserMessage = userMessages[userMessages.length - 1];
-              const prompt = lastUserMessage ? lastUserMessage.content : "";
-              const engineOptions = {
-                maxTokens: options.maxTokens,
-                temperature: options.temperature,
-                messages: options.messages,
-                systemPrompt: options.messages.find((m5) => m5.role === "system")?.content
-              };
-              const engineStream = engine.query(prompt, engineOptions);
-              async function* createTextStream() {
-                for await (const message of engineStream) {
-                  if (message.type === "text" && message.content) {
-                    yield message.content;
-                  } else if (typeof message === "string") {
-                    yield message;
-                  }
-                }
+            for await (const message of engineStream) {
+              if (abortSignal.aborted) {
+                const abortError = new Error("Operation aborted");
+                abortError.name = "AbortError";
+                throw abortError;
               }
-              return {
-                textStream: createTextStream(),
-                usage: Promise.resolve({})
-                // Engine should handle its own usage tracking
-                // Add other streamText-compatible properties as needed
-              };
-            }
-          } catch (error2) {
-            if (this.debug) {
-              console.log(`[DEBUG] Failed to use Claude Code engine, falling back to Vercel:`, error2.message);
-            }
-          }
-        }
-        if (this.clientApiProvider === "codex" || process.env.USE_CODEX === "true") {
-          try {
-            const engine = await this.getEngine();
-            if (engine && engine.query) {
-              const userMessages = options.messages.filter(
-                (m5) => m5.role === "user" && !m5.content.includes("WARNING: You have reached the maximum tool iterations limit")
-              );
-              const lastUserMessage = userMessages[userMessages.length - 1];
-              const prompt = lastUserMessage ? lastUserMessage.content : "";
-              const engineOptions = {
-                maxTokens: options.maxTokens,
-                temperature: options.temperature,
-                messages: options.messages,
-                systemPrompt: options.messages.find((m5) => m5.role === "system")?.content
-              };
-              const engineStream = engine.query(prompt, engineOptions);
-              async function* createTextStream() {
-                for await (const message of engineStream) {
-                  if (message.type === "text" && message.content) {
-                    yield message.content;
-                  } else if (typeof message === "string") {
-                    yield message;
-                  }
-                }
+              const now = Date.now();
+              if (now - lastActivity > activityTimeout) {
+                throw new Error(`Engine stream timeout - no activity for ${activityTimeout}ms`);
+              }
+              if (requestTimeout > 0 && now - startTime > requestTimeout) {
+                throw new Error(`Engine stream timeout - request exceeded ${requestTimeout}ms`);
+              }
+              lastActivity = now;
+              if (message.type === "text" && message.content) {
+                yield message.content;
+              } else if (typeof message === "string") {
+                yield message;
               }
-              return {
-                textStream: createTextStream(),
-                usage: Promise.resolve({})
-                // Engine should handle its own usage tracking
-                // Add other streamText-compatible properties as needed
-              };
             }
-          } catch (error2) {
-            if (this.debug) {
-              console.log(`[DEBUG] Failed to use Codex engine, falling back to Vercel:`, error2.message);
+          } finally {
+            if (timeoutState.timeoutId) {
+              clearTimeout(timeoutState.timeoutId);
+              timeoutState.timeoutId = null;
             }
           }
         }
+        return {
+          textStream: createTextStream(),
+          usage: Promise.resolve({})
+          // Engine should handle its own usage tracking
+          // Add other streamText-compatible properties as needed
+        };
+      }
+      /**
+       * Try to use an engine (claude-code or codex) for streaming
+       * @param {Object} options - streamText options
+       * @param {AbortController} controller - Abort controller for the operation
+       * @param {Object} timeoutState - Mutable timeout state for cleanup
+       * @returns {Promise<Object|null>} - Stream result or null if engine unavailable
+       * @private
+       */
+      async _tryEngineStreamPath(options, controller, timeoutState) {
+        const engine = await this.getEngine();
+        if (!engine || !engine.query) {
+          return null;
+        }
+        const userMessages = options.messages.filter(
+          (m5) => m5.role === "user" && !m5.content.includes("WARNING: You have reached the maximum tool iterations limit")
+        );
+        const lastUserMessage = userMessages[userMessages.length - 1];
+        const prompt = lastUserMessage ? lastUserMessage.content : "";
+        const engineOptions = {
+          maxTokens: options.maxTokens,
+          temperature: options.temperature,
+          messages: options.messages,
+          systemPrompt: options.messages.find((m5) => m5.role === "system")?.content,
+          abortSignal: controller.signal
+        };
+        const engineStream = engine.query(prompt, engineOptions);
+        return this._createEngineTextStreamResult(
+          engineStream,
+          controller.signal,
+          this.requestTimeout,
+          timeoutState
+        );
+      }
+      /**
+       * Execute streamText with Vercel AI SDK using retry/fallback logic
+       * @param {Object} options - streamText options
+       * @param {AbortController} controller - Abort controller for the operation
+       * @returns {Promise<Object>} - Stream result
+       * @private
+       */
+      async _executeWithVercelProvider(options, controller) {
         if (!this.retryManager) {
           this.retryManager = new RetryManager({
             maxRetries: this.retryConfig.maxRetries ?? 3,
@@ -96805,10 +96939,11 @@ var init_ProbeAgent = __esm({
         }
         if (!this.fallbackManager) {
           return await this.retryManager.executeWithRetry(
-            () => (0, import_ai3.streamText)(options),
+            () => (0, import_ai3.streamText)({ ...options, abortSignal: controller.signal }),
             {
               provider: this.apiType,
-              model: this.model
+              model: this.model,
+              signal: controller.signal
             }
           );
         }
@@ -96816,7 +96951,8 @@ var init_ProbeAgent = __esm({
           async (provider, model, config) => {
             const fallbackOptions = {
               ...options,
-              model: provider(model)
+              model: provider(model),
+              abortSignal: controller.signal
             };
             const providerRetryManager = new RetryManager({
               maxRetries: config.maxRetries ?? this.retryConfig.maxRetries ?? 3,
@@ -96830,12 +96966,54 @@ var init_ProbeAgent = __esm({
               () => (0, import_ai3.streamText)(fallbackOptions),
               {
                 provider: config.provider,
-                model
+                model,
+                signal: controller.signal
               }
             );
           }
         );
       }
+      /**
+       * Execute streamText with retry and fallback support
+       * @param {Object} options - streamText options
+       * @returns {Promise<Object>} - streamText result
+       * @private
+       */
+      async streamTextWithRetryAndFallback(options) {
+        const controller = new AbortController();
+        const timeoutState = { timeoutId: null };
+        if (this.maxOperationTimeout && this.maxOperationTimeout > 0) {
+          timeoutState.timeoutId = setTimeout(() => {
+            controller.abort();
+            if (this.debug) {
+              console.log(`[DEBUG] Operation timed out after ${this.maxOperationTimeout}ms (max operation timeout)`);
+            }
+          }, this.maxOperationTimeout);
+        }
+        try {
+          const useClaudeCode = this.clientApiProvider === "claude-code" || process.env.USE_CLAUDE_CODE === "true";
+          const useCodex = this.clientApiProvider === "codex" || process.env.USE_CODEX === "true";
+          if (useClaudeCode || useCodex) {
+            try {
+              const result = await this._tryEngineStreamPath(options, controller, timeoutState);
+              if (result) {
+                return result;
+              }
+            } catch (error2) {
+              if (this.debug) {
+                const engineType = useClaudeCode ? "Claude Code" : "Codex";
+                console.log(`[DEBUG] Failed to use ${engineType} engine, falling back to Vercel:`, error2.message);
+              }
+            }
+          }
+          return await this._executeWithVercelProvider(options, controller);
+        } finally {
+          if (timeoutState.timeoutId) {
+            clearTimeout(timeoutState.timeoutId);
+            timeoutState.timeoutId = null;
+          }
+        }
+      }
       /**
        * Initialize Anthropic model
        */