@browserbasehq/stagehand 1.2.0 → 1.3.0

package/dist/index.js

@@ -604,13 +604,15 @@ var OpenAIClient = class {
     return __async(this, null, function* () {
       const _a = options, { image: _ } = _a, optionsWithoutImage = __objRest(_a, ["image"]);
       this.logger({
-        category: "OpenAI",
-        message: `Creating chat completion with options: ${JSON.stringify(
-          optionsWithoutImage,
-          null,
-          2
-        )}`,
-        level: 1
+        category: "openai",
+        message: "creating chat completion",
+        level: 1,
+        auxiliary: {
+          options: {
+            value: JSON.stringify(optionsWithoutImage),
+            type: "object"
+          }
+        }
       });
       const cacheOptions = {
         model: options.model,
@@ -627,15 +629,31 @@ var OpenAIClient = class {
         if (cachedResponse) {
           this.logger({
             category: "llm_cache",
-            message: `LLM Cache hit - returning cached response`,
-            level: 1
+            message: "LLM cache hit - returning cached response",
+            level: 1,
+            auxiliary: {
+              requestId: {
+                value: this.requestId,
+                type: "string"
+              },
+              cachedResponse: {
+                value: JSON.stringify(cachedResponse),
+                type: "object"
+              }
+            }
           });
           return cachedResponse;
         } else {
           this.logger({
             category: "llm_cache",
-            message: `LLM Cache miss - no cached response found`,
-            level: 1
+            message: "LLM cache miss - no cached response found",
+            level: 1,
+            auxiliary: {
+              requestId: {
+                value: this.requestId,
+                type: "string"
+              }
+            }
           });
         }
       }
@@ -666,9 +684,19 @@ var OpenAIClient = class {
         response_format: responseFormat
       }));
       this.logger({
-        category: "OpenAI",
-        message: `Response: ${JSON.stringify(response, null, 2)}`,
-        level: 1
+        category: "openai",
+        message: "response",
+        level: 1,
+        auxiliary: {
+          response: {
+            value: JSON.stringify(response),
+            type: "object"
+          },
+          requestId: {
+            value: this.requestId,
+            type: "string"
+          }
+        }
       });
       if (response_model) {
         const extractedData = response.choices[0].message.content;
@@ -683,6 +711,25 @@ var OpenAIClient = class {
         return __spreadValues({}, parsedData);
       }
       if (this.enableCaching) {
+        this.logger({
+          category: "llm_cache",
+          message: "caching response",
+          level: 1,
+          auxiliary: {
+            requestId: {
+              value: this.requestId,
+              type: "string"
+            },
+            cacheOptions: {
+              value: JSON.stringify(cacheOptions),
+              type: "object"
+            },
+            response: {
+              value: JSON.stringify(response),
+              type: "object"
+            }
+          }
+        });
         this.cache.set(cacheOptions, response, this.requestId);
       }
       return response;
@@ -708,13 +755,15 @@ var AnthropicClient = class {
       var _b, _c, _d, _e, _f, _g, _h;
       const _a = options, { image: _ } = _a, optionsWithoutImage = __objRest(_a, ["image"]);
       this.logger({
-        category: "Anthropic",
-        message: `Creating chat completion with options: ${JSON.stringify(
-          optionsWithoutImage,
-          null,
-          2
-        )}`,
-        level: 1
+        category: "anthropic",
+        message: "creating chat completion",
+        level: 1,
+        auxiliary: {
+          options: {
+            value: JSON.stringify(optionsWithoutImage),
+            type: "object"
+          }
+        }
       });
       const cacheOptions = {
         model: options.model,
@@ -730,15 +779,39 @@ var AnthropicClient = class {
         if (cachedResponse) {
           this.logger({
             category: "llm_cache",
-            message: `LLM Cache hit - returning cached response`,
-            level: 1
+            message: "LLM cache hit - returning cached response",
+            level: 1,
+            auxiliary: {
+              cachedResponse: {
+                value: JSON.stringify(cachedResponse),
+                type: "object"
+              },
+              requestId: {
+                value: this.requestId,
+                type: "string"
+              },
+              cacheOptions: {
+                value: JSON.stringify(cacheOptions),
+                type: "object"
+              }
+            }
           });
           return cachedResponse;
         } else {
           this.logger({
             category: "llm_cache",
-            message: `LLM Cache miss - no cached response found`,
-            level: 1
+            message: "LLM cache miss - no cached response found",
+            level: 1,
+            auxiliary: {
+              cacheOptions: {
+                value: JSON.stringify(cacheOptions),
+                type: "object"
+              },
+              requestId: {
+                value: this.requestId,
+                type: "string"
+              }
+            }
           });
         }
       }
@@ -808,9 +881,19 @@ var AnthropicClient = class {
         temperature: options.temperature
       });
       this.logger({
-        category: "Anthropic",
-        message: `Response: ${JSON.stringify(response, null, 2)}`,
-        level: 1
+        category: "anthropic",
+        message: "response",
+        level: 1,
+        auxiliary: {
+          response: {
+            value: JSON.stringify(response),
+            type: "object"
+          },
+          requestId: {
+            value: this.requestId,
+            type: "string"
+          }
+        }
       });
       const transformedResponse = {
         id: response.id,
@@ -842,8 +925,19 @@ var AnthropicClient = class {
         }
       };
       this.logger({
-        category: "Anthropic",
-        message: "Transformed response: " + JSON.stringify(transformedResponse)
+        category: "anthropic",
+        message: "transformed response",
+        level: 1,
+        auxiliary: {
+          transformedResponse: {
+            value: JSON.stringify(transformedResponse),
+            type: "object"
+          },
+          requestId: {
+            value: this.requestId,
+            type: "string"
+          }
+        }
       });
       if (options.response_model) {
         const toolUse = response.content.find((c) => c.type === "tool_use");
@@ -859,6 +953,17 @@ var AnthropicClient = class {
               retries: ((_h = options.retries) != null ? _h : 0) + 1
             }));
           }
+          this.logger({
+            category: "anthropic",
+            message: "error creating chat completion",
+            level: 1,
+            auxiliary: {
+              requestId: {
+                value: this.requestId,
+                type: "string"
+              }
+            }
+          });
           throw new Error(
             "Create Chat Completion Failed: No tool use with input in response"
           );
@@ -866,6 +971,25 @@ var AnthropicClient = class {
       }
       if (this.enableCaching) {
         this.cache.set(cacheOptions, transformedResponse, this.requestId);
+        this.logger({
+          category: "anthropic",
+          message: "cached response",
+          level: 1,
+          auxiliary: {
+            requestId: {
+              value: this.requestId,
+              type: "string"
+            },
+            transformedResponse: {
+              value: JSON.stringify(transformedResponse),
+              type: "object"
+            },
+            cacheOptions: {
+              value: JSON.stringify(cacheOptions),
+              type: "object"
+            }
+          }
+        });
       }
       return transformedResponse;
     });
@@ -904,8 +1028,18 @@ var BaseCache = class {
     process.on("uncaughtException", (err) => {
       this.logger({
         category: "base_cache",
-        message: `Uncaught exception: ${err}`,
-        level: 2
+        message: "uncaught exception",
+        level: 2,
+        auxiliary: {
+          error: {
+            value: err.message,
+            type: "string"
+          },
+          trace: {
+            value: err.stack,
+            type: "string"
+          }
+        }
       });
       if (this.lockAcquired) {
         releaseLockAndExit();
@@ -917,8 +1051,14 @@ var BaseCache = class {
       fs.mkdirSync(this.cacheDir, { recursive: true });
       this.logger({
         category: "base_cache",
-        message: `Created cache directory at ${this.cacheDir}`,
-        level: 1
+        message: "created cache directory",
+        level: 1,
+        auxiliary: {
+          cacheDir: {
+            value: this.cacheDir,
+            type: "string"
+          }
+        }
       });
     }
   }
@@ -989,8 +1129,18 @@ var BaseCache = class {
     } catch (error) {
       this.logger({
         category: "base_cache",
-        message: `Error releasing lock: ${error}`,
-        level: 2
+        message: "error releasing lock",
+        level: 2,
+        auxiliary: {
+          error: {
+            value: error.message,
+            type: "string"
+          },
+          trace: {
+            value: error.stack,
+            type: "string"
+          }
+        }
       });
     }
   }
@@ -1002,7 +1152,7 @@ var BaseCache = class {
       if (!(yield this.acquireLock())) {
         this.logger({
           category: "llm_cache",
-          message: "Failed to acquire lock for cleanup",
+          message: "failed to acquire lock for cleanup",
           level: 2
         });
         return;
@@ -1021,15 +1171,31 @@ var BaseCache = class {
           this.writeCache(cache);
           this.logger({
             category: "llm_cache",
-            message: `Cleaned up ${entriesRemoved} stale cache entries`,
-            level: 1
+            message: "cleaned up stale cache entries",
+            level: 1,
+            auxiliary: {
+              entriesRemoved: {
+                value: entriesRemoved.toString(),
+                type: "integer"
+              }
+            }
           });
         }
       } catch (error) {
         this.logger({
           category: "llm_cache",
-          message: `Error during cache cleanup: ${error}`,
-          level: 2
+          message: "error during cache cleanup",
+          level: 2,
+          auxiliary: {
+            error: {
+              value: error.message,
+              type: "string"
+            },
+            trace: {
+              value: error.stack,
+              type: "string"
+            }
+          }
         });
       } finally {
         this.releaseLock();
@@ -1044,8 +1210,18 @@ var BaseCache = class {
       } catch (error) {
         this.logger({
           category: "base_cache",
-          message: `Error reading cache file: ${error}. Resetting cache.`,
-          level: 1
+          message: "error reading cache file. resetting cache.",
+          level: 1,
+          auxiliary: {
+            error: {
+              value: error.message,
+              type: "string"
+            },
+            trace: {
+              value: error.stack,
+              type: "string"
+            }
+          }
         });
         this.resetCache();
         return {};
@@ -1064,8 +1240,18 @@ var BaseCache = class {
     } catch (error) {
       this.logger({
         category: "base_cache",
-        message: `Error writing cache file: ${error}`,
-        level: 2
+        message: "error writing cache file",
+        level: 2,
+        auxiliary: {
+          error: {
+            value: error.message,
+            type: "string"
+          },
+          trace: {
+            value: error.stack,
+            type: "string"
+          }
+        }
       });
     } finally {
       this.releaseLock();
@@ -1098,8 +1284,18 @@ var BaseCache = class {
       } catch (error) {
         this.logger({
           category: "base_cache",
-          message: `Error getting cache: ${error}. Resetting cache.`,
-          level: 1
+          message: "error getting cache. resetting cache.",
+          level: 1,
+          auxiliary: {
+            error: {
+              value: error.message,
+              type: "string"
+            },
+            trace: {
+              value: error.stack,
+              type: "string"
+            }
+          }
         });
         this.resetCache();
         return null;
@@ -1137,8 +1333,18 @@ var BaseCache = class {
       } catch (error) {
         this.logger({
           category: "base_cache",
-          message: `Error setting cache: ${error}. Resetting cache.`,
-          level: 1
+          message: "error setting cache. resetting cache.",
+          level: 1,
+          auxiliary: {
+            error: {
+              value: error.message,
+              type: "string"
+            },
+            trace: {
+              value: error.stack,
+              type: "string"
+            }
+          }
         });
         this.resetCache();
       } finally {
@@ -1175,8 +1381,18 @@ var BaseCache = class {
       } catch (error) {
         this.logger({
           category: "base_cache",
-          message: `Error removing cache entry: ${error}`,
-          level: 2
+          message: "error removing cache entry",
+          level: 2,
+          auxiliary: {
+            error: {
+              value: error.message,
+              type: "string"
+            },
+            trace: {
+              value: error.stack,
+              type: "string"
+            }
+          }
         });
       } finally {
         this.releaseLock();
@@ -1223,16 +1439,36 @@ var BaseCache = class {
         } else {
           this.logger({
             category: "base_cache",
-            message: `No cache entries found for requestId ${requestId}`,
-            level: 1
+            message: "no cache entries found for requestId",
+            level: 1,
+            auxiliary: {
+              requestId: {
+                value: requestId,
+                type: "string"
+              }
+            }
           });
         }
         delete this.requestIdToUsedHashes[requestId];
       } catch (error) {
         this.logger({
           category: "base_cache",
-          message: `Error deleting cache for requestId ${requestId}: ${error}`,
-          level: 2
+          message: "error deleting cache for requestId",
+          level: 2,
+          auxiliary: {
+            error: {
+              value: error.message,
+              type: "string"
+            },
+            trace: {
+              value: error.stack,
+              type: "string"
+            },
+            requestId: {
+              value: requestId,
+              type: "string"
+            }
+          }
         });
       } finally {
         this.releaseLock();
@@ -1249,8 +1485,18 @@ var BaseCache = class {
     } catch (error) {
       this.logger({
         category: "base_cache",
-        message: `Error resetting cache: ${error}`,
-        level: 2
+        message: "error resetting cache",
+        level: 2,
+        auxiliary: {
+          error: {
+            value: error.message,
+            type: "string"
+          },
+          trace: {
+            value: error.stack,
+            type: "string"
+          }
+        }
       });
     } finally {
       this.releaseLock();
@@ -1306,12 +1552,22 @@ var LLMProvider = class {
     };
     this.logger = logger;
     this.enableCaching = enableCaching;
-    this.cache = new LLMCache(logger);
+    this.cache = enableCaching ? new LLMCache(logger) : void 0;
   }
   cleanRequestCache(requestId) {
+    if (!this.enableCaching) {
+      return;
+    }
     this.logger({
       category: "llm_cache",
-      message: `Cleaning up cache for requestId: ${requestId}`
+      message: "cleaning up cache",
+      level: 1,
+      auxiliary: {
+        requestId: {
+          value: requestId,
+          type: "string"
+        }
+      }
     });
     this.cache.deleteCacheForRequestId(requestId);
   }
@@ -1341,31 +1597,45 @@ var LLMProvider = class {
   }
 };
 
-// lib/index.ts
-var import_path2 = __toESM(require("path"));
-
 // lib/vision.ts
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_sharp = __toESM(require("sharp"));
 var import_child_process = require("child_process");
-var ScreenshotService = class _ScreenshotService {
-  constructor(page, selectorMap, verbose, isDebugEnabled = false) {
+
+// lib/utils.ts
+var import_crypto = __toESM(require("crypto"));
+function generateId(operation) {
+  return import_crypto.default.createHash("sha256").update(operation).digest("hex");
+}
+function logLineToString(logLine) {
+  var _a;
+  const timestamp = logLine.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  if ((_a = logLine.auxiliary) == null ? void 0 : _a.error) {
+    return `${timestamp}::[stagehand:${logLine.category}] ${logLine.message}
+ ${logLine.auxiliary.error.value}
+ ${logLine.auxiliary.trace.value}`;
+  }
+  return `${timestamp}::[stagehand:${logLine.category}] ${logLine.message} ${logLine.auxiliary ? JSON.stringify(logLine.auxiliary) : ""}`;
+}
+
+// lib/vision.ts
+var ScreenshotService = class {
+  constructor(page, selectorMap, verbose, externalLogger, isDebugEnabled = false) {
     this.annotationBoxes = [];
     this.numberPositions = [];
     this.page = page;
     this.selectorMap = selectorMap;
     this.isDebugEnabled = isDebugEnabled;
     this.verbose = verbose;
+    this.externalLogger = externalLogger;
   }
-  log({
-    category,
-    message,
-    level = 1
-  }) {
-    if (this.verbose >= level) {
-      const categoryString = category ? `:${category}` : "";
-      console.log(`[stagehand${categoryString}] ${message}`);
+  log(logLine) {
+    if (this.verbose >= logLine.level) {
+      console.log(logLineToString(logLine));
+    }
+    if (this.externalLogger) {
+      this.externalLogger(logLine);
     }
   }
   getScreenshot(fullpage = true, quality) {
@@ -1382,21 +1652,40 @@ var ScreenshotService = class _ScreenshotService {
   }
   getScreenshotPixelCount(screenshot) {
     return __async(this, null, function* () {
+      var _a, _b, _c, _d;
       const image = (0, import_sharp.default)(screenshot);
       const metadata = yield image.metadata();
       if (!metadata.width || !metadata.height) {
         this.log({
-          category: "Error",
+          category: "screenshotService",
           message: "Unable to determine image dimensions.",
-          level: 0
+          level: 0,
+          auxiliary: {
+            width: {
+              value: (_b = (_a = metadata.width) == null ? void 0 : _a.toString()) != null ? _b : "undefined",
+              type: "string"
+              // might be undefined
+            },
+            height: {
+              value: (_d = (_c = metadata.height) == null ? void 0 : _c.toString()) != null ? _d : "undefined",
+              type: "string"
+              // might be undefined
+            }
+          }
         });
         throw new Error("Unable to determine image dimensions.");
       }
       const pixelCount = metadata.width * metadata.height;
       this.log({
-        category: "Info",
-        message: `Screenshot pixel count: ${pixelCount}`,
-        level: 1
+        category: "screenshotService",
+        message: "got screenshot pixel count",
+        level: 1,
+        auxiliary: {
+          pixelCount: {
+            value: pixelCount.toString(),
+            type: "integer"
+          }
+        }
       });
       return pixelCount;
     });
@@ -1408,6 +1697,17 @@ var ScreenshotService = class _ScreenshotService {
       const screenshot = yield this.getScreenshot(fullpage);
       const image = (0, import_sharp.default)(screenshot);
       const { width, height } = yield image.metadata();
+      this.log({
+        category: "screenshotService",
+        message: "annotating screenshot",
+        level: 2,
+        auxiliary: {
+          selectorMap: {
+            value: JSON.stringify(this.selectorMap),
+            type: "object"
+          }
+        }
+      });
       const svgAnnotations = yield Promise.all(
         Object.entries(this.selectorMap).map(
           (_0) => __async(this, [_0], function* ([id, selectors]) {
@@ -1428,7 +1728,7 @@ var ScreenshotService = class _ScreenshotService {
     `;
       const annotatedScreenshot = yield image.composite([{ input: Buffer.from(svg), top: 0, left: 0 }]).toBuffer();
       if (this.isDebugEnabled) {
-        yield _ScreenshotService.saveAndOpenScreenshot(annotatedScreenshot);
+        yield this.saveAndOpenScreenshot(annotatedScreenshot);
       }
       return annotatedScreenshot;
     });
@@ -1478,9 +1778,23 @@ var ScreenshotService = class _ScreenshotService {
       `;
       } catch (error) {
         this.log({
-          category: "Vision",
-          message: `Warning: Failed to create annotation for element ${id}: ${error}, trace: ${error.stack}`,
-          level: 0
+          category: "screenshotService",
+          message: "warning: failed to create annotation for element",
+          level: 1,
+          auxiliary: {
+            element_id: {
+              value: id,
+              type: "string"
+            },
+            error: {
+              value: error.message,
+              type: "string"
+            },
+            trace: {
+              value: error.stack,
+              type: "string"
+            }
+          }
         });
         return "";
       }
@@ -1510,7 +1824,7 @@ var ScreenshotService = class _ScreenshotService {
       ) < circleRadius * 2
     );
   }
-  static saveAndOpenScreenshot(screenshot) {
+  saveAndOpenScreenshot(screenshot) {
     return __async(this, null, function* () {
       const screenshotDir = import_path.default.join(process.cwd(), "screenshots");
       if (!import_fs.default.existsSync(screenshotDir)) {
@@ -1519,7 +1833,17 @@ var ScreenshotService = class _ScreenshotService {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const filename = import_path.default.join(screenshotDir, `screenshot-${timestamp}.png`);
       import_fs.default.writeFileSync(filename, screenshot);
-      console.log(`Screenshot saved to: ${filename}`);
+      this.log({
+        category: "screenshotService",
+        message: "screenshot saved",
+        level: 1,
+        auxiliary: {
+          filename: {
+            value: filename,
+            type: "string"
+          }
+        }
+      });
       if (process.platform === "win32") {
         (0, import_child_process.exec)(`start ${filename}`);
       } else if (process.platform === "darwin") {
@@ -1564,8 +1888,26 @@ var ActionCache = class _ActionCache extends BaseCache {
     }) {
       this.logger({
         category: "action_cache",
-        message: `Adding action step to cache: ${action}, requestId: ${requestId}, url: ${url}, previousSelectors: ${previousSelectors}`,
-        level: 1
+        message: "adding action step to cache",
+        level: 1,
+        auxiliary: {
+          action: {
+            value: action,
+            type: "string"
+          },
+          requestId: {
+            value: requestId,
+            type: "string"
+          },
+          url: {
+            value: url,
+            type: "string"
+          },
+          previousSelectors: {
+            value: JSON.stringify(previousSelectors),
+            type: "object"
+          }
+        }
       });
       yield this.set(
         { url, action, previousSelectors },
@@ -1617,8 +1959,14 @@ var ActionCache = class _ActionCache extends BaseCache {
       yield __superGet(_ActionCache.prototype, this, "deleteCacheForRequestId").call(this, requestId);
       this.logger({
         category: "action_cache",
-        message: `Cleared action for ID: ${requestId}`,
-        level: 1
+        message: "cleared action for ID",
+        level: 1,
+        auxiliary: {
+          requestId: {
+            value: requestId,
+            type: "string"
+          }
+        }
       });
     });
   }
@@ -1637,12 +1985,6 @@ var ActionCache = class _ActionCache extends BaseCache {
   }
 };
 
-// lib/utils.ts
-var import_crypto = __toESM(require("crypto"));
-function generateId(operation) {
-  return import_crypto.default.createHash("sha256").update(operation).digest("hex");
-}
-
 // lib/handlers/actHandler.ts
 var StagehandActHandler = class {
   constructor({
@@ -1662,7 +2004,7 @@ var StagehandActHandler = class {
     this.enableCaching = enableCaching;
     this.logger = logger;
     this.waitForSettledDom = waitForSettledDom;
-    this.actionCache = new ActionCache(this.logger);
+    this.actionCache = enableCaching ? new ActionCache(this.logger) : void 0;
     this.defaultModelName = defaultModelName;
     this.startDomDebug = startDomDebug;
     this.cleanupDomDebug = cleanupDomDebug;
@@ -1693,8 +2035,14 @@ var StagehandActHandler = class {
       if (completed) {
         this.stagehand.log({
           category: "action",
-          message: `Action marked as completed, Verifying if this is true...`,
-          level: 1
+          message: "action marked as completed, verifying if this is true...",
+          level: 1,
+          auxiliary: {
+            action: {
+              value: action,
+              type: "string"
+            }
+          }
         });
         let domElements = void 0;
         let fullpageScreenshot = void 0;
@@ -1703,20 +2051,31 @@ var StagehandActHandler = class {
             const screenshotService = new ScreenshotService(
               this.stagehand.page,
               selectorMap,
-              this.verbose
+              this.verbose,
+              this.logger
             );
             fullpageScreenshot = yield screenshotService.getScreenshot(true, 15);
           } catch (e) {
             this.stagehand.log({
               category: "action",
-              message: `Error getting full page screenshot: ${e.message}
-. Trying again...`,
-              level: 1
+              message: "error getting full page screenshot. trying again...",
+              level: 1,
+              auxiliary: {
+                error: {
+                  value: e.message,
+                  type: "string"
+                },
+                trace: {
+                  value: e.stack,
+                  type: "string"
+                }
+              }
             });
             const screenshotService = new ScreenshotService(
               this.stagehand.page,
               selectorMap,
-              this.verbose
+              this.verbose,
+              this.logger
             );
             fullpageScreenshot = yield screenshotService.getScreenshot(true, 15);
           }
@@ -1739,8 +2098,18 @@ var StagehandActHandler = class {
         });
         this.stagehand.log({
           category: "action",
-          message: `Action completion verification result: ${actionCompleted}`,
-          level: 1
+          message: "action completion verification result",
+          level: 1,
+          auxiliary: {
+            action: {
+              value: action,
+              type: "string"
+            },
+            result: {
+              value: actionCompleted.toString(),
+              type: "boolean"
+            }
+          }
         });
       }
       return actionCompleted;
@@ -1748,13 +2117,20 @@ var StagehandActHandler = class {
   }
   _performPlaywrightMethod(method, args, xpath, domSettleTimeoutMs) {
     return __async(this, null, function* () {
+      var _a, _b;
       const locator = this.stagehand.page.locator(`xpath=${xpath}`).first();
       const initialUrl = this.stagehand.page.url();
       if (method === "scrollIntoView") {
         this.stagehand.log({
           category: "action",
-          message: `Scrolling element into view`,
-          level: 2
+          message: "scrolling element into view",
+          level: 2,
+          auxiliary: {
+            xpath: {
+              value: xpath,
+              type: "string"
+            }
+          }
         });
         try {
           yield locator.evaluate((element) => {
@@ -1762,17 +2138,43 @@ var StagehandActHandler = class {
           }).catch((e) => {
             this.stagehand.log({
               category: "action",
-              message: `Error scrolling element into view: ${e.message}
-Trace: ${e.stack}`,
-              level: 1
+              message: "error scrolling element into view",
+              level: 1,
+              auxiliary: {
+                error: {
+                  value: e.message,
+                  type: "string"
+                },
+                trace: {
+                  value: e.stack,
+                  type: "string"
+                },
+                xpath: {
+                  value: xpath,
+                  type: "string"
+                }
+              }
             });
           });
         } catch (e) {
           this.stagehand.log({
             category: "action",
-            message: `Error scrolling element into view: ${e.message}
-Trace: ${e.stack}`,
-            level: 1
+            message: "error scrolling element into view",
+            level: 1,
+            auxiliary: {
+              error: {
+                value: e.message,
+                type: "string"
+              },
+              trace: {
+                value: e.stack,
+                type: "string"
+              },
+              xpath: {
+                value: xpath,
+                type: "string"
+              }
+            }
           });
           throw new PlaywrightCommandException(e.message);
         }
@@ -1789,9 +2191,22 @@ Trace: ${e.stack}`,
         } catch (e) {
           this.logger({
             category: "action",
-            message: `Error filling element: ${e.message}
-Trace: ${e.stack}`,
-            level: 1
+            message: "error filling element",
+            level: 1,
+            auxiliary: {
+              error: {
+                value: e.message,
+                type: "string"
+              },
+              trace: {
+                value: e.stack,
+                type: "string"
+              },
+              xpath: {
+                value: xpath,
+                type: "string"
+              }
+            }
           });
           throw new PlaywrightCommandException(e.message);
         }
@@ -1802,36 +2217,80 @@ Trace: ${e.stack}`,
         } catch (e) {
           this.logger({
             category: "action",
-            message: `Error pressing key: ${e.message}
-Trace: ${e.stack}`,
-            level: 1
+            message: "error pressing key",
+            level: 1,
+            auxiliary: {
+              error: {
+                value: e.message,
+                type: "string"
+              },
+              trace: {
+                value: e.stack,
+                type: "string"
+              },
+              key: {
+                value: (_b = (_a = args[0]) == null ? void 0 : _a.toString()) != null ? _b : "unknown",
+                type: "string"
+              }
+            }
           });
           throw new PlaywrightCommandException(e.message);
         }
       } else if (typeof locator[method] === "function") {
         this.logger({
           category: "action",
-          message: `Page URL before action: ${this.stagehand.page.url()}`,
-          level: 2
+          message: "page URL before action",
+          level: 2,
+          auxiliary: {
+            url: {
+              value: this.stagehand.page.url(),
+              type: "string"
+            }
+          }
         });
         try {
           yield locator[method](...args);
         } catch (e) {
           this.logger({
             category: "action",
-            message: `Error performing method ${method} with args ${JSON.stringify(
-              args
-            )}: ${e.message}
-Trace: ${e.stack}`,
-            level: 1
+            message: "error performing method",
+            level: 1,
+            auxiliary: {
+              error: {
+                value: e.message,
+                type: "string"
+              },
+              trace: {
+                value: e.stack,
+                type: "string"
+              },
+              xpath: {
+                value: xpath,
+                type: "string"
+              },
+              method: {
+                value: method,
+                type: "string"
+              },
+              args: {
+                value: JSON.stringify(args),
+                type: "object"
+              }
+            }
           });
           throw new PlaywrightCommandException(e.message);
         }
         if (method === "click") {
           this.logger({
             category: "action",
-            message: `Clicking element, checking for page navigation`,
-            level: 1
+            message: "clicking element, checking for page navigation",
+            level: 1,
+            auxiliary: {
+              xpath: {
+                value: xpath,
+                type: "string"
+              }
+            }
           });
           const newOpenedTab = yield Promise.race([
             new Promise((resolve) => {
@@ -1841,14 +2300,26 @@ Trace: ${e.stack}`,
           ]);
           this.logger({
             category: "action",
-            message: `Clicked element, ${newOpenedTab ? "opened a new tab" : "no new tabs opened"}`,
-            level: 1
+            message: "clicked element",
+            level: 1,
+            auxiliary: {
+              newOpenedTab: {
+                value: newOpenedTab ? "opened a new tab" : "no new tabs opened",
+                type: "string"
+              }
+            }
           });
           if (newOpenedTab) {
             this.logger({
               category: "action",
-              message: `New page detected (new tab) with URL: ${newOpenedTab.url()}`,
-              level: 1
+              message: "new page detected (new tab) with URL",
+              level: 1,
+              auxiliary: {
+                url: {
+                  value: newOpenedTab.url(),
+                  type: "string"
+                }
+              }
             });
             yield newOpenedTab.close();
             yield this.stagehand.page.goto(newOpenedTab.url());
@@ -1861,28 +2332,40 @@ Trace: ${e.stack}`,
           ]).catch((e) => {
             this.logger({
               category: "action",
-              message: `Network idle timeout hit`,
+              message: "network idle timeout hit",
               level: 1
             });
           });
           this.logger({
             category: "action",
-            message: `Finished waiting for (possible) page navigation`,
+            message: "finished waiting for (possible) page navigation",
             level: 1
           });
           if (this.stagehand.page.url() !== initialUrl) {
             this.logger({
               category: "action",
-              message: `New page detected with URL: ${this.stagehand.page.url()}`,
-              level: 1
+              message: "new page detected with URL",
+              level: 1,
+              auxiliary: {
+                url: {
+                  value: this.stagehand.page.url(),
+                  type: "string"
+                }
+              }
             });
           }
         }
       } else {
         this.logger({
           category: "action",
-          message: `Chosen method ${method} is invalid`,
-          level: 1
+          message: "chosen method is invalid",
+          level: 1,
+          auxiliary: {
+            method: {
+              value: method,
+              type: "string"
+            }
+          }
         });
         throw new PlaywrightCommandMethodNotSupportedException(
           `Method ${method} not supported`
@@ -1924,8 +2407,18 @@ Trace: ${e.stack}`,
       } catch (e) {
         this.logger({
           category: "action",
-          message: `Element with XPath ${xpath} not found within ${timeout}ms.`,
-          level: 1
+          message: "element not found within timeout",
+          level: 1,
+          auxiliary: {
+            xpath: {
+              value: xpath,
+              type: "string"
+            },
+            timeout_ms: {
+              value: timeout.toString(),
+              type: "integer"
+            }
+          }
         });
         return null;
       }
@@ -1935,34 +2428,62 @@ Trace: ${e.stack}`,
     return __async(this, null, function* () {
       this.logger({
         category: "action",
-        message: `Checking if cached step is valid: ${cachedStep.xpath}, ${cachedStep.savedComponentString}`,
-        level: 1
+        message: "checking if cached step is valid",
+        level: 1,
+        auxiliary: {
+          xpath: {
+            value: cachedStep.xpath,
+            type: "string"
+          },
+          savedComponentString: {
+            value: cachedStep.savedComponentString,
+            type: "string"
+          }
+        }
       });
       try {
         const locator = yield this.getElement(cachedStep.xpath);
         if (!locator) {
           this.logger({
             category: "action",
-            message: `Locator not found for xpath: ${cachedStep.xpath}`,
-            level: 1
+            message: "locator not found for xpath",
+            level: 1,
+            auxiliary: {
+              xpath: {
+                value: cachedStep.xpath,
+                type: "string"
+              }
+            }
           });
           return false;
         }
         this.logger({
           category: "action",
-          message: `locator element: ${yield this._getComponentString(locator)}`,
-          level: 1
+          message: "locator element",
+          level: 1,
+          auxiliary: {
+            componentString: {
+              value: yield this._getComponentString(locator),
+              type: "string"
+            }
+          }
         });
         let currentComponent = yield this._getComponentString(locator);
         this.logger({
           category: "action",
-          message: `Current text: ${currentComponent}`,
-          level: 1
+          message: "current text",
+          level: 1,
+          auxiliary: {
+            componentString: {
+              value: currentComponent,
+              type: "string"
+            }
+          }
         });
         if (!currentComponent || !cachedStep.savedComponentString) {
           this.logger({
             category: "action",
-            message: `Current text or cached text is undefined`,
+            message: "current text or cached text is undefined",
             level: 1
           });
           return false;
@@ -1972,8 +2493,18 @@ Trace: ${e.stack}`,
         if (normalizedCurrentText !== normalizedCachedText) {
           this.logger({
             category: "action",
-            message: `Current text and cached text do not match: ${normalizedCurrentText} !== ${normalizedCachedText}`,
-            level: 1
+            message: "current text and cached text do not match",
+            level: 1,
+            auxiliary: {
+              currentText: {
+                value: normalizedCurrentText,
+                type: "string"
+              },
+              cachedText: {
+                value: normalizedCachedText,
+                type: "string"
+              }
+            }
           });
           return false;
         }
@@ -1981,9 +2512,18 @@ Trace: ${e.stack}`,
       } catch (e) {
         this.logger({
           category: "action",
-          message: `Error checking if cached step is valid: ${e.message}
-Trace: ${e.stack}`,
-          level: 1
+          message: "error checking if cached step is valid",
+          level: 1,
+          auxiliary: {
+            error: {
+              value: e.message,
+              type: "string"
+            },
+            trace: {
+              value: e.stack,
+              type: "string"
+            }
+          }
         });
         return false;
       }
@@ -2019,6 +2559,10 @@ Trace: ${e.stack}`,
       model,
       domSettleTimeoutMs
     }) {
+      var _a, _b;
+      if (!this.enableCaching) {
+        return null;
+      }
       const cacheObj = {
         url: this.stagehand.page.url(),
         action,
@@ -2027,24 +2571,40 @@ Trace: ${e.stack}`,
       };
       this.logger({
         category: "action",
-        message: `Checking action cache for: ${JSON.stringify(cacheObj)}`,
-        level: 1
+        message: "checking action cache",
+        level: 1,
+        auxiliary: {
+          cacheObj: {
+            value: JSON.stringify(cacheObj),
+            type: "object"
+          }
+        }
       });
       const cachedStep = yield this.actionCache.getActionStep(cacheObj);
       if (!cachedStep) {
         this.logger({
           category: "action",
-          message: `Action cache miss: ${JSON.stringify(cacheObj)}`,
-          level: 1
+          message: "action cache miss",
+          level: 1,
+          auxiliary: {
+            cacheObj: {
+              value: JSON.stringify(cacheObj),
+              type: "object"
+            }
+          }
         });
         return null;
       }
       this.logger({
         category: "action",
-        message: `Action cache semi-hit: ${cachedStep.playwrightCommand.method} with args: ${JSON.stringify(
-          cachedStep.playwrightCommand.args
-        )}`,
-        level: 1
+        message: "action cache semi-hit",
+        level: 1,
+        auxiliary: {
+          playwrightCommand: {
+            value: JSON.stringify(cachedStep.playwrightCommand),
+            type: "object"
+          }
+        }
       });
       try {
         const validXpath = yield this._getValidCachedStepXpath({
@@ -2053,24 +2613,40 @@ Trace: ${e.stack}`,
         });
         this.logger({
           category: "action",
-          message: `Cached action step is valid: ${validXpath !== null}`,
-          level: 1
+          message: "cached action step is valid",
+          level: 1,
+          auxiliary: {
+            validXpath: {
+              value: validXpath,
+              type: "string"
+            }
+          }
         });
         if (!validXpath) {
           this.logger({
             category: "action",
-            message: `Cached action step is invalid, removing...`,
-            level: 1
+            message: "cached action step is invalid, removing...",
+            level: 1,
+            auxiliary: {
+              cacheObj: {
+                value: JSON.stringify(cacheObj),
+                type: "object"
+              }
+            }
           });
-          yield this.actionCache.removeActionStep(cacheObj);
+          yield (_a = this.actionCache) == null ? void 0 : _a.removeActionStep(cacheObj);
           return null;
         }
         this.logger({
           category: "action",
-          message: `Action Cache Hit: ${cachedStep.playwrightCommand.method} with args: ${JSON.stringify(
-            cachedStep.playwrightCommand.args
-          )}`,
-          level: 1
+          message: "action cache hit",
+          level: 1,
+          auxiliary: {
+            playwrightCommand: {
+              value: JSON.stringify(cachedStep.playwrightCommand),
+              type: "object"
+            }
+          }
         });
         cachedStep.playwrightCommand.args = cachedStep.playwrightCommand.args.map(
           (arg) => {
@@ -2102,13 +2678,19 @@ Trace: ${e.stack}`,
           });
           this.logger({
             category: "action",
-            message: `Action completion verification result from cache: ${actionCompleted}`,
-            level: 1
+            message: "action completion verification result from cache",
+            level: 1,
+            auxiliary: {
+              actionCompleted: {
+                value: actionCompleted.toString(),
+                type: "boolean"
+              }
+            }
           });
           if (actionCompleted) {
             return {
               success: true,
-              message: "Action completed successfully using cached step",
+              message: "action completed successfully using cached step",
               action
             };
           }
@@ -2130,11 +2712,20 @@ Trace: ${e.stack}`,
       } catch (exception) {
         this.logger({
           category: "action",
-          message: `Error performing cached action step: ${exception.message}
-Trace: ${exception.stack}`,
-          level: 1
+          message: "error performing cached action step",
+          level: 1,
+          auxiliary: {
+            error: {
+              value: exception.message,
+              type: "string"
+            },
+            trace: {
+              value: exception.stack,
+              type: "string"
+            }
+          }
         });
-        yield this.actionCache.removeActionStep(cacheObj);
+        yield (_b = this.actionCache) == null ? void 0 : _b.removeActionStep(cacheObj);
         return null;
       }
     });
@@ -2154,7 +2745,7 @@ Trace: ${exception.stack}`,
       skipActionCacheForThisStep = false,
       domSettleTimeoutMs
     }) {
-      var _a;
+      var _a, _b;
       try {
         yield this.waitForSettledDom(domSettleTimeoutMs);
         yield this.startDomDebug();
@@ -2196,20 +2787,40 @@ Trace: ${exception.stack}`,
         if (!modelsWithVision.includes(model) && (useVision !== false || verifierUseVision)) {
           this.logger({
             category: "action",
-            message: `${model} does not support vision, but useVision was set to ${useVision}. Defaulting to false.`,
-            level: 1
+            message: "model does not support vision but useVision was not false. defaulting to false.",
+            level: 1,
+            auxiliary: {
+              model: {
+                value: model,
+                type: "string"
+              },
+              useVision: {
+                value: useVision.toString(),
+                type: "boolean"
+              }
+            }
           });
           useVision = false;
           verifierUseVision = false;
         }
         this.logger({
           category: "action",
-          message: `Running / Continuing action: ${action} on page: ${this.stagehand.page.url()}`,
-          level: 2
+          message: "running / continuing action",
+          level: 2,
+          auxiliary: {
+            action: {
+              value: action,
+              type: "string"
+            },
+            pageUrl: {
+              value: this.stagehand.page.url(),
+              type: "string"
+            }
+          }
         });
         this.logger({
           category: "action",
-          message: `Processing DOM...`,
+          message: "processing DOM",
           level: 2
         });
         const { outputString, selectorMap, chunk, chunks } = yield this.stagehand.page.evaluate(
@@ -2220,22 +2831,47 @@ Trace: ${exception.stack}`,
         );
         this.logger({
           category: "action",
-          message: `Looking at chunk ${chunk}. Chunks left: ${chunks.length - chunksSeen.length}`,
-          level: 1
+          message: "looking at chunk",
+          level: 1,
+          auxiliary: {
+            chunk: {
+              value: chunk.toString(),
+              type: "integer"
+            },
+            chunks: {
+              value: chunks.length.toString(),
+              type: "integer"
+            },
+            chunksSeen: {
+              value: chunksSeen.length.toString(),
+              type: "integer"
+            },
+            chunksLeft: {
+              value: (chunks.length - chunksSeen.length).toString(),
+              type: "integer"
+            }
+          }
         });
         let annotatedScreenshot;
         if (useVision === true) {
           if (!modelsWithVision.includes(model)) {
             this.logger({
               category: "action",
-              message: `${model} does not support vision. Skipping vision processing.`,
-              level: 1
+              message: "model does not support vision. skipping vision processing.",
+              level: 1,
+              auxiliary: {
+                model: {
+                  value: model,
+                  type: "string"
+                }
+              }
             });
           } else {
             const screenshotService = new ScreenshotService(
               this.stagehand.page,
               selectorMap,
-              this.verbose
+              this.verbose,
+              this.logger
             );
             annotatedScreenshot = yield screenshotService.getAnnotatedScreenshot(false);
           }
@@ -2253,8 +2889,14 @@ Trace: ${exception.stack}`,
         });
         this.logger({
           category: "action",
-          message: `Received response from LLM: ${JSON.stringify(response)}`,
-          level: 1
+          message: "received response from LLM",
+          level: 1,
+          auxiliary: {
+            response: {
+              value: JSON.stringify(response),
+              type: "object"
+            }
+          }
         });
         yield this.cleanupDomDebug();
         if (!response) {
@@ -2262,8 +2904,14 @@ Trace: ${exception.stack}`,
             chunksSeen.push(chunk);
             this.logger({
               category: "action",
-              message: `No action found in current chunk. Chunks seen: ${chunksSeen.length}.`,
-              level: 1
+              message: "no action found in current chunk",
+              level: 1,
+              auxiliary: {
+                chunksSeen: {
+                  value: chunksSeen.length.toString(),
+                  type: "integer"
+                }
+              }
             });
             return this.act({
               action,
@@ -2281,8 +2929,14 @@ Trace: ${exception.stack}`,
           } else if (useVision === "fallback") {
             this.logger({
               category: "action",
-              message: `Switching to vision-based processing`,
-              level: 1
+              message: "switching to vision-based processing",
+              level: 1,
+              auxiliary: {
+                useVision: {
+                  value: useVision.toString(),
+                  type: "string"
+                }
+              }
             });
             yield this.stagehand.page.evaluate(() => window.scrollToHeight(0));
             return yield this.act({
@@ -2301,7 +2955,7 @@ Trace: ${exception.stack}`,
           } else {
             if (this.enableCaching) {
               this.llmProvider.cleanRequestCache(requestId);
-              this.actionCache.deleteCacheForRequestId(requestId);
+              (_a = this.actionCache) == null ? void 0 : _a.deleteCacheForRequestId(requestId);
             }
             return {
               success: false,
@@ -2315,13 +2969,29 @@ Trace: ${exception.stack}`,
         const method = response["method"];
         const args = response["args"];
         const elementLines = outputString.split("\n");
-        const elementText = ((_a = elementLines.find((line) => line.startsWith(`${elementId}:`))) == null ? void 0 : _a.split(":")[1]) || "Element not found";
+        const elementText = ((_b = elementLines.find((line) => line.startsWith(`${elementId}:`))) == null ? void 0 : _b.split(":")[1]) || "Element not found";
         this.logger({
           category: "action",
-          message: `Executing method: ${method} on element: ${elementId} (xpaths: ${xpaths.join(
-            ", "
-          )}) with args: ${JSON.stringify(args)}`,
-          level: 1
+          message: "executing method",
+          level: 1,
+          auxiliary: {
+            method: {
+              value: method,
+              type: "string"
+            },
+            elementId: {
+              value: elementId.toString(),
+              type: "integer"
+            },
+            xpaths: {
+              value: JSON.stringify(xpaths),
+              type: "object"
+            },
+            args: {
+              value: JSON.stringify(args),
+              type: "object"
+            }
+          }
         });
         try {
           const initialUrl = this.stagehand.page.url();
@@ -2365,9 +3035,18 @@ Trace: ${exception.stack}`,
             }).catch((e) => {
               this.logger({
                 category: "action",
-                message: `Error adding action step to cache: ${e.message}
-Trace: ${e.stack}`,
-                level: 1
+                message: "error adding action step to cache",
+                level: 1,
+                auxiliary: {
+                  error: {
+                    value: e.message,
+                    type: "string"
+                  },
+                  trace: {
+                    value: e.stack,
+                    type: "string"
+                  }
+                }
               });
             });
           }
@@ -2388,7 +3067,7 @@ Trace: ${e.stack}`,
           if (!actionCompleted) {
             this.logger({
               category: "action",
-              message: `Continuing to next action step`,
+              message: "continuing to next action step",
               level: 1
             });
             return this.act({
@@ -2407,7 +3086,7 @@ Trace: ${e.stack}`,
           } else {
             this.logger({
               category: "action",
-              message: `Action completed successfully`,
+              message: "action completed successfully",
               level: 1
             });
             yield this._recordAction(action, response.step);
@@ -2420,9 +3099,22 @@ Trace: ${e.stack}`,
         } catch (error) {
           this.logger({
             category: "action",
-            message: `Error performing action - D (Retries: ${retries}): ${error.message}
-Trace: ${error.stack}`,
-            level: 1
+            message: "error performing action - d",
+            level: 1,
+            auxiliary: {
+              error: {
+                value: error.message,
+                type: "string"
+              },
+              trace: {
+                value: error.stack,
+                type: "string"
+              },
+              retries: {
+                value: retries.toString(),
+                type: "integer"
+              }
+            }
           });
           if (retries < 2) {
             return this.act({
@@ -2447,16 +3139,25 @@ Trace: ${error.stack}`,
           }
           return {
             success: false,
-            message: `Error performing action - A: ${error.message}`,
+            message: "error performing action - a",
             action
           };
         }
       } catch (error) {
         this.logger({
           category: "action",
-          message: `Error performing action - B: ${error.message}
-Trace: ${error.stack}`,
-          level: 1
+          message: "error performing action - b",
+          level: 1,
+          auxiliary: {
+            error: {
+              value: error.message,
+              type: "string"
+            },
+            trace: {
+              value: error.stack,
+              type: "string"
+            }
+          }
         });
         if (this.enableCaching) {
           this.llmProvider.cleanRequestCache(requestId);
@@ -2472,14 +3173,18 @@ Trace: ${error.stack}`,
   }
 };
 
+// lib/dom/build/scriptContent.ts
+var scriptContent = '(() => {\n  // lib/dom/xpathUtils.ts\n  function getParentElement(node) {\n    return isElementNode(node) ? node.parentElement : node.parentNode;\n  }\n  function getCombinations(attributes, size) {\n    const results = [];\n    function helper(start, combo) {\n      if (combo.length === size) {\n        results.push([...combo]);\n        return;\n      }\n      for (let i = start; i < attributes.length; i++) {\n        combo.push(attributes[i]);\n        helper(i + 1, combo);\n        combo.pop();\n      }\n    }\n    helper(0, []);\n    return results;\n  }\n  function isXPathFirstResultElement(xpath, target) {\n    try {\n      const result = document.evaluate(\n        xpath,\n        document.documentElement,\n        null,\n        XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,\n        null\n      );\n      return result.snapshotItem(0) === target;\n    } catch (error) {\n      console.warn(`Invalid XPath expression: ${xpath}`, error);\n      return false;\n    }\n  }\n  function escapeXPathString(value) {\n    if (value.includes("\'")) {\n      if (value.includes(\'"\')) {\n        return "concat(" + value.split(/(\'+)/).map((part) => {\n          if (part === "\'") {\n            return `"\'"`;\n          } else if (part.startsWith("\'") && part.endsWith("\'")) {\n            return `"${part}"`;\n          } else {\n            return `\'${part}\'`;\n          }\n        }).join(",") + ")";\n      } else {\n        return `"${value}"`;\n      }\n    } else {\n      return `\'${value}\'`;\n    }\n  }\n  async function generateXPathsForElement(element) {\n    if (!element) return [];\n    const [complexXPath, standardXPath, idBasedXPath] = await Promise.all([\n      generateComplexXPath(element),\n      generateStandardXPath(element),\n      generatedIdBasedXPath(element)\n    ]);\n    return [standardXPath, ...idBasedXPath ? [idBasedXPath] : [], complexXPath];\n  }\n  async function generateComplexXPath(element) {\n    const parts = [];\n    let currentElement = element;\n    while (currentElement && (isTextNode(currentElement) || isElementNode(currentElement))) {\n      if (isElementNode(currentElement)) {\n        const el = currentElement;\n        let selector = el.tagName.toLowerCase();\n        const attributePriority = [\n          "data-qa",\n          "data-component",\n          "data-role",\n          "role",\n          "aria-role",\n          "type",\n          "name",\n          "aria-label",\n          "placeholder",\n          "title",\n          "alt"\n        ];\n        const attributes = attributePriority.map((attr) => {\n          let value = el.getAttribute(attr);\n          if (attr === "href-full" && value) {\n            value = el.getAttribute("href");\n          }\n          return value ? { attr: attr === "href-full" ? "href" : attr, value } : null;\n        }).filter((attr) => attr !== null);\n        let uniqueSelector = "";\n        for (let i = 1; i <= attributes.length; i++) {\n          const combinations = getCombinations(attributes, i);\n          for (const combo of combinations) {\n            const conditions = combo.map((a) => `@${a.attr}=${escapeXPathString(a.value)}`).join(" and ");\n            const xpath2 = `//${selector}[${conditions}]`;\n            if (isXPathFirstResultElement(xpath2, el)) {\n              uniqueSelector = xpath2;\n              break;\n            }\n          }\n          if (uniqueSelector) break;\n        }\n        if (uniqueSelector) {\n          parts.unshift(uniqueSelector.replace("//", ""));\n          break;\n        } else {\n          const parent = getParentElement(el);\n          if (parent) {\n            const siblings = Array.from(parent.children).filter(\n              (sibling) => sibling.tagName === el.tagName\n            );\n            const index = siblings.indexOf(el) + 1;\n            selector += siblings.length > 1 ? `[${index}]` : "";\n          }\n          parts.unshift(selector);\n        }\n      }\n      currentElement = getParentElement(currentElement);\n    }\n    const xpath = "//" + parts.join("/");\n    return xpath;\n  }\n  async function generateStandardXPath(element) {\n    const parts = [];\n    while (element && (isTextNode(element) || isElementNode(element))) {\n      let index = 0;\n      let hasSameTypeSiblings = false;\n      const siblings = element.parentElement ? Array.from(element.parentElement.childNodes) : [];\n      for (let i = 0; i < siblings.length; i++) {\n        const sibling = siblings[i];\n        if (sibling.nodeType === element.nodeType && sibling.nodeName === element.nodeName) {\n          index = index + 1;\n          hasSameTypeSiblings = true;\n          if (sibling.isSameNode(element)) {\n            break;\n          }\n        }\n      }\n      if (element.nodeName !== "#text") {\n        const tagName = element.nodeName.toLowerCase();\n        const pathIndex = hasSameTypeSiblings ? `[${index}]` : "";\n        parts.unshift(`${tagName}${pathIndex}`);\n      }\n      element = element.parentElement;\n    }\n    return parts.length ? `/${parts.join("/")}` : "";\n  }\n  async function generatedIdBasedXPath(element) {\n    if (isElementNode(element) && element.id) {\n      return `//*[@id=\'${element.id}\']`;\n    }\n    return null;\n  }\n\n  // lib/dom/process.ts\n  function isElementNode(node) {\n    return node.nodeType === Node.ELEMENT_NODE;\n  }\n  function isTextNode(node) {\n    return node.nodeType === Node.TEXT_NODE && Boolean(node.textContent?.trim());\n  }\n  async function processDom(chunksSeen) {\n    const { chunk, chunksArray } = await pickChunk(chunksSeen);\n    const { outputString, selectorMap } = await processElements(chunk);\n    console.log(\n      `Stagehand (Browser Process): Extracted dom elements:\n${outputString}`\n    );\n    return {\n      outputString,\n      selectorMap,\n      chunk,\n      chunks: chunksArray\n    };\n  }\n  async function processAllOfDom() {\n    console.log("Stagehand (Browser Process): Processing all of DOM");\n    const viewportHeight = window.innerHeight;\n    const documentHeight = document.documentElement.scrollHeight;\n    const totalChunks = Math.ceil(documentHeight / viewportHeight);\n    let index = 0;\n    const results = [];\n    for (let chunk = 0; chunk < totalChunks; chunk++) {\n      const result = await processElements(chunk, true, index);\n      results.push(result);\n      index += Object.keys(result.selectorMap).length;\n    }\n    await scrollToHeight(0);\n    const allOutputString = results.map((result) => result.outputString).join("");\n    const allSelectorMap = results.reduce(\n      (acc, result) => ({ ...acc, ...result.selectorMap }),\n      {}\n    );\n    console.log(\n      `Stagehand (Browser Process): All dom elements: ${allOutputString}`\n    );\n    return {\n      outputString: allOutputString,\n      selectorMap: allSelectorMap\n    };\n  }\n  async function scrollToHeight(height) {\n    window.scrollTo({ top: height, left: 0, behavior: "smooth" });\n    await new Promise((resolve) => {\n      let scrollEndTimer;\n      const handleScrollEnd = () => {\n        clearTimeout(scrollEndTimer);\n        scrollEndTimer = window.setTimeout(() => {\n          window.removeEventListener("scroll", handleScrollEnd);\n          resolve();\n        }, 100);\n      };\n      window.addEventListener("scroll", handleScrollEnd, { passive: true });\n      handleScrollEnd();\n    });\n  }\n  var xpathCache = /* @__PURE__ */ new Map();\n  async function processElements(chunk, scrollToChunk = true, indexOffset = 0) {\n    console.time("processElements:total");\n    const viewportHeight = window.innerHeight;\n    const chunkHeight = viewportHeight * chunk;\n    const maxScrollTop = document.documentElement.scrollHeight - window.innerHeight;\n    const offsetTop = Math.min(chunkHeight, maxScrollTop);\n    if (scrollToChunk) {\n      console.time("processElements:scroll");\n      await scrollToHeight(offsetTop);\n      console.timeEnd("processElements:scroll");\n    }\n    const candidateElements = [];\n    const DOMQueue = [...document.body.childNodes];\n    console.log("Stagehand (Browser Process): Generating candidate elements");\n    console.time("processElements:findCandidates");\n    while (DOMQueue.length > 0) {\n      const element = DOMQueue.pop();\n      let shouldAddElement = false;\n      if (element && isElementNode(element)) {\n        const childrenCount = element.childNodes.length;\n        for (let i = childrenCount - 1; i >= 0; i--) {\n          const child = element.childNodes[i];\n          DOMQueue.push(child);\n        }\n        if (isInteractiveElement(element)) {\n          if (isActive(element) && isVisible(element)) {\n            shouldAddElement = true;\n          }\n        }\n        if (isLeafElement(element)) {\n          if (isActive(element) && isVisible(element)) {\n            shouldAddElement = true;\n          }\n        }\n      }\n      if (element && isTextNode(element) && isTextVisible(element)) {\n        shouldAddElement = true;\n      }\n      if (shouldAddElement) {\n        candidateElements.push(element);\n      }\n    }\n    console.timeEnd("processElements:findCandidates");\n    const selectorMap = {};\n    let outputString = "";\n    console.log(\n      `Stagehand (Browser Process): Processing candidate elements: ${candidateElements.length}`\n    );\n    console.time("processElements:processCandidates");\n    console.time("processElements:generateXPaths");\n    const xpathLists = await Promise.all(\n      candidateElements.map(async (element) => {\n        if (xpathCache.has(element)) {\n          return xpathCache.get(element);\n        }\n        const xpaths = await generateXPathsForElement(element);\n        xpathCache.set(element, xpaths);\n        return xpaths;\n      })\n    );\n    console.timeEnd("processElements:generateXPaths");\n    candidateElements.forEach((element, index) => {\n      const xpaths = xpathLists[index];\n      let elementOutput = "";\n      if (isTextNode(element)) {\n        const textContent = element.textContent?.trim();\n        if (textContent) {\n          elementOutput += `${index + indexOffset}:${textContent}\n`;\n        }\n      } else if (isElementNode(element)) {\n        const tagName = element.tagName.toLowerCase();\n        const attributes = collectEssentialAttributes(element);\n        const openingTag = `<${tagName}${attributes ? " " + attributes : ""}>`;\n        const closingTag = `</${tagName}>`;\n        const textContent = element.textContent?.trim() || "";\n        elementOutput += `${index + indexOffset}:${openingTag}${textContent}${closingTag}\n`;\n      }\n      outputString += elementOutput;\n      selectorMap[index + indexOffset] = xpaths;\n    });\n    console.timeEnd("processElements:processCandidates");\n    console.timeEnd("processElements:total");\n    return {\n      outputString,\n      selectorMap\n    };\n  }\n  function collectEssentialAttributes(element) {\n    const essentialAttributes = [\n      "id",\n      "class",\n      "href",\n      "src",\n      "aria-label",\n      "aria-name",\n      "aria-role",\n      "aria-description",\n      "aria-expanded",\n      "aria-haspopup"\n    ];\n    const attrs = essentialAttributes.map((attr) => {\n      const value = element.getAttribute(attr);\n      return value ? `${attr}="${value}"` : "";\n    }).filter((attr) => attr !== "");\n    Array.from(element.attributes).forEach((attr) => {\n      if (attr.name.startsWith("data-")) {\n        attrs.push(`${attr.name}="${attr.value}"`);\n      }\n    });\n    return attrs.join(" ");\n  }\n  window.processDom = processDom;\n  window.processAllOfDom = processAllOfDom;\n  window.processElements = processElements;\n  window.scrollToHeight = scrollToHeight;\n  var leafElementDenyList = ["SVG", "IFRAME", "SCRIPT", "STYLE", "LINK"];\n  var interactiveElementTypes = [\n    "A",\n    "BUTTON",\n    "DETAILS",\n    "EMBED",\n    "INPUT",\n    "LABEL",\n    "MENU",\n    "MENUITEM",\n    "OBJECT",\n    "SELECT",\n    "TEXTAREA",\n    "SUMMARY"\n  ];\n  var interactiveRoles = [\n    "button",\n    "menu",\n    "menuitem",\n    "link",\n    "checkbox",\n    "radio",\n    "slider",\n    "tab",\n    "tabpanel",\n    "textbox",\n    "combobox",\n    "grid",\n    "listbox",\n    "option",\n    "progressbar",\n    "scrollbar",\n    "searchbox",\n    "switch",\n    "tree",\n    "treeitem",\n    "spinbutton",\n    "tooltip"\n  ];\n  var interactiveAriaRoles = ["menu", "menuitem", "button"];\n  var isVisible = (element) => {\n    const rect = element.getBoundingClientRect();\n    if (rect.width === 0 || rect.height === 0 || rect.top < 0 || rect.top > window.innerHeight) {\n      return false;\n    }\n    if (!isTopElement(element, rect)) {\n      return false;\n    }\n    const visible = element.checkVisibility({\n      checkOpacity: true,\n      checkVisibilityCSS: true\n    });\n    return visible;\n  };\n  var isTextVisible = (element) => {\n    const range = document.createRange();\n    range.selectNodeContents(element);\n    const rect = range.getBoundingClientRect();\n    if (rect.width === 0 || rect.height === 0 || rect.top < 0 || rect.top > window.innerHeight) {\n      return false;\n    }\n    const parent = element.parentElement;\n    if (!parent) {\n      return false;\n    }\n    if (!isTopElement(parent, rect)) {\n      return false;\n    }\n    const visible = parent.checkVisibility({\n      checkOpacity: true,\n      checkVisibilityCSS: true\n    });\n    return visible;\n  };\n  function isTopElement(elem, rect) {\n    const points = [\n      { x: rect.left + rect.width * 0.25, y: rect.top + rect.height * 0.25 },\n      { x: rect.left + rect.width * 0.75, y: rect.top + rect.height * 0.25 },\n      { x: rect.left + rect.width * 0.25, y: rect.top + rect.height * 0.75 },\n      { x: rect.left + rect.width * 0.75, y: rect.top + rect.height * 0.75 },\n      { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 }\n    ];\n    return points.some((point) => {\n      const topEl = document.elementFromPoint(point.x, point.y);\n      let current = topEl;\n      while (current && current !== document.body) {\n        if (current.isSameNode(elem)) {\n          return true;\n        }\n        current = current.parentElement;\n      }\n      return false;\n    });\n  }\n  var isActive = (element) => {\n    if (element.hasAttribute("disabled") || element.hasAttribute("hidden") || element.getAttribute("aria-disabled") === "true") {\n      return false;\n    }\n    return true;\n  };\n  var isInteractiveElement = (element) => {\n    const elementType = element.tagName;\n    const elementRole = element.getAttribute("role");\n    const elementAriaRole = element.getAttribute("aria-role");\n    return elementType && interactiveElementTypes.includes(elementType) || elementRole && interactiveRoles.includes(elementRole) || elementAriaRole && interactiveAriaRoles.includes(elementAriaRole);\n  };\n  var isLeafElement = (element) => {\n    if (element.textContent === "") {\n      return false;\n    }\n    if (element.childNodes.length === 0) {\n      return !leafElementDenyList.includes(element.tagName);\n    }\n    if (element.childNodes.length === 1 && isTextNode(element.childNodes[0])) {\n      return true;\n    }\n    return false;\n  };\n  async function pickChunk(chunksSeen) {\n    const viewportHeight = window.innerHeight;\n    const documentHeight = document.documentElement.scrollHeight;\n    const chunks = Math.ceil(documentHeight / viewportHeight);\n    const chunksArray = Array.from({ length: chunks }, (_, i) => i);\n    const chunksRemaining = chunksArray.filter((chunk2) => {\n      return !chunksSeen.includes(chunk2);\n    });\n    const currentScrollPosition = window.scrollY;\n    const closestChunk = chunksRemaining.reduce((closest, current) => {\n      const currentChunkTop = viewportHeight * current;\n      const closestChunkTop = viewportHeight * closest;\n      return Math.abs(currentScrollPosition - currentChunkTop) < Math.abs(currentScrollPosition - closestChunkTop) ? current : closest;\n    }, chunksRemaining[0]);\n    const chunk = closestChunk;\n    if (chunk === void 0) {\n      throw new Error(`No chunks remaining to check: ${chunksRemaining}`);\n    }\n    return {\n      chunk,\n      chunksArray\n    };\n  }\n\n  // lib/dom/utils.ts\n  async function waitForDomSettle() {\n    return new Promise((resolve) => {\n      const createTimeout = () => {\n        return setTimeout(() => {\n          resolve();\n        }, 2e3);\n      };\n      let timeout = createTimeout();\n      const observer = new MutationObserver(() => {\n        clearTimeout(timeout);\n        timeout = createTimeout();\n      });\n      observer.observe(window.document.body, { childList: true, subtree: true });\n    });\n  }\n  window.waitForDomSettle = waitForDomSettle;\n\n  // lib/dom/debug.ts\n  async function debugDom() {\n    window.chunkNumber = 0;\n    const { selectorMap: multiSelectorMap, outputString } = await window.processElements(window.chunkNumber);\n    const selectorMap = multiSelectorMapToSelectorMap(multiSelectorMap);\n    drawChunk(selectorMap);\n    setupChunkNav();\n  }\n  function multiSelectorMapToSelectorMap(multiSelectorMap) {\n    return Object.fromEntries(\n      Object.entries(multiSelectorMap).map(([key, selectors]) => [\n        Number(key),\n        selectors[0]\n      ])\n    );\n  }\n  function drawChunk(selectorMap) {\n    cleanupMarkers();\n    Object.entries(selectorMap).forEach(([_index, selector]) => {\n      const element = document.evaluate(\n        selector,\n        document,\n        null,\n        XPathResult.FIRST_ORDERED_NODE_TYPE,\n        null\n      ).singleNodeValue;\n      if (element) {\n        let rect;\n        if (element.nodeType === Node.ELEMENT_NODE) {\n          rect = element.getBoundingClientRect();\n        } else {\n          const range = document.createRange();\n          range.selectNodeContents(element);\n          rect = range.getBoundingClientRect();\n        }\n        const color = "grey";\n        const overlay = document.createElement("div");\n        overlay.style.position = "absolute";\n        overlay.style.left = `${rect.left + window.scrollX}px`;\n        overlay.style.top = `${rect.top + window.scrollY}px`;\n        overlay.style.padding = "2px";\n        overlay.style.width = `${rect.width}px`;\n        overlay.style.height = `${rect.height}px`;\n        overlay.style.backgroundColor = color;\n        overlay.className = "stagehand-marker";\n        overlay.style.opacity = "0.3";\n        overlay.style.zIndex = "1000000000";\n        overlay.style.border = "1px solid";\n        overlay.style.pointerEvents = "none";\n        document.body.appendChild(overlay);\n      }\n    });\n  }\n  async function cleanupDebug() {\n    cleanupMarkers();\n    cleanupNav();\n  }\n  function cleanupMarkers() {\n    const markers = document.querySelectorAll(".stagehand-marker");\n    markers.forEach((marker) => {\n      marker.remove();\n    });\n  }\n  function cleanupNav() {\n    const stagehandNavElements = document.querySelectorAll(".stagehand-nav");\n    stagehandNavElements.forEach((element) => {\n      element.remove();\n    });\n  }\n  function setupChunkNav() {\n    const viewportHeight = window.innerHeight;\n    const documentHeight = document.documentElement.scrollHeight;\n    const totalChunks = Math.ceil(documentHeight / viewportHeight);\n    if (window.chunkNumber > 0) {\n      const prevChunkButton = document.createElement("button");\n      prevChunkButton.className = "stagehand-nav";\n      prevChunkButton.textContent = "Previous";\n      prevChunkButton.style.marginLeft = "50px";\n      prevChunkButton.style.position = "fixed";\n      prevChunkButton.style.bottom = "10px";\n      prevChunkButton.style.left = "50%";\n      prevChunkButton.style.transform = "translateX(-50%)";\n      prevChunkButton.style.zIndex = "1000000000";\n      prevChunkButton.onclick = async () => {\n        cleanupMarkers();\n        cleanupNav();\n        window.chunkNumber -= 1;\n        window.scrollTo(0, window.chunkNumber * window.innerHeight);\n        await window.waitForDomSettle();\n        const { selectorMap: multiSelectorMap } = await window.processElements(\n          window.chunkNumber\n        );\n        const selectorMap = multiSelectorMapToSelectorMap(multiSelectorMap);\n        drawChunk(selectorMap);\n        setupChunkNav();\n      };\n      document.body.appendChild(prevChunkButton);\n    }\n    if (totalChunks > window.chunkNumber) {\n      const nextChunkButton = document.createElement("button");\n      nextChunkButton.className = "stagehand-nav";\n      nextChunkButton.textContent = "Next";\n      nextChunkButton.style.marginRight = "50px";\n      nextChunkButton.style.position = "fixed";\n      nextChunkButton.style.bottom = "10px";\n      nextChunkButton.style.right = "50%";\n      nextChunkButton.style.transform = "translateX(50%)";\n      nextChunkButton.style.zIndex = "1000000000";\n      nextChunkButton.onclick = async () => {\n        cleanupMarkers();\n        cleanupNav();\n        window.chunkNumber += 1;\n        window.scrollTo(0, window.chunkNumber * window.innerHeight);\n        await window.waitForDomSettle();\n        const { selectorMap: multiSelectorMap } = await window.processElements(\n          window.chunkNumber\n        );\n        const selectorMap = multiSelectorMapToSelectorMap(multiSelectorMap);\n        drawChunk(selectorMap);\n        setupChunkNav();\n      };\n      document.body.appendChild(nextChunkButton);\n    }\n  }\n  window.debugDom = debugDom;\n  window.cleanupDebug = cleanupDebug;\n})();\n';
+
 // lib/index.ts
+var import_crypto2 = require("crypto");
 require("dotenv").config({ path: ".env" });
 function getBrowser(apiKey, projectId, env = "LOCAL", headless = false, logger, browserbaseSessionCreateParams, browserbaseResumeSessionID) {
   return __async(this, null, function* () {
     if (env === "BROWSERBASE") {
       if (!apiKey) {
         logger({
-          category: "Init",
+          category: "init",
           message: "BROWSERBASE_API_KEY is required to use BROWSERBASE env. Defaulting to LOCAL.",
           level: 0
         });
@@ -2487,7 +3192,7 @@ function getBrowser(apiKey, projectId, env = "LOCAL", headless = false, logger,
       }
       if (!projectId) {
         logger({
-          category: "Init",
+          category: "init",
           message: "BROWSERBASE_PROJECT_ID is required for some Browserbase features that may not work without it.",
           level: 1
         });
@@ -2517,22 +3222,38 @@ function getBrowser(apiKey, projectId, env = "LOCAL", headless = false, logger,
           sessionId = browserbaseResumeSessionID;
           connectUrl = `wss://connect.browserbase.com?apiKey=${apiKey}&sessionId=${sessionId}`;
           logger({
-            category: "Init",
-            message: "Resuming existing Browserbase session...",
-            level: 0
+            category: "init",
+            message: "resuming existing browserbase session...",
+            level: 1,
+            auxiliary: {
+              sessionId: {
+                value: sessionId,
+                type: "string"
+              }
+            }
           });
         } catch (error) {
           logger({
-            category: "Init",
-            message: `Failed to resume session ${browserbaseResumeSessionID}: ${error.message}`,
-            level: 0
+            category: "init",
+            message: "failed to resume session",
+            level: 1,
+            auxiliary: {
+              error: {
+                value: error.message,
+                type: "string"
+              },
+              trace: {
+                value: error.stack,
+                type: "string"
+              }
+            }
           });
           throw error;
         }
       } else {
         logger({
-          category: "Init",
-          message: "Creating new Browserbase session...",
+          category: "init",
+          message: "creating new browserbase session...",
           level: 0
         });
         if (!projectId) {
@@ -2545,27 +3266,54 @@ function getBrowser(apiKey, projectId, env = "LOCAL", headless = false, logger,
         }, browserbaseSessionCreateParams));
         sessionId = session.id;
         connectUrl = session.connectUrl;
+        logger({
+          category: "init",
+          message: "created new browserbase session",
+          level: 1,
+          auxiliary: {
+            sessionId: {
+              value: sessionId,
+              type: "string"
+            }
+          }
+        });
       }
       const browser = yield import_test.chromium.connectOverCDP(connectUrl);
       const { debuggerUrl } = yield browserbase.sessions.debug(sessionId);
       debugUrl = debuggerUrl;
       sessionUrl = `https://www.browserbase.com/sessions/${sessionId}`;
       logger({
-        category: "Init",
-        message: `Browserbase session ${browserbaseResumeSessionID ? "resumed" : "started"}.
-
-Session Url: ${sessionUrl}
-
-Live debug accessible here: ${debugUrl}.`,
-        level: 0
+        category: "init",
+        message: browserbaseResumeSessionID ? "browserbase session resumed" : "browserbase session started",
+        level: 0,
+        auxiliary: {
+          sessionUrl: {
+            value: sessionUrl,
+            type: "string"
+          },
+          debugUrl: {
+            value: debugUrl,
+            type: "string"
+          },
+          sessionId: {
+            value: sessionId,
+            type: "string"
+          }
+        }
       });
       const context = browser.contexts()[0];
       return { browser, context, debugUrl, sessionUrl };
     } else {
       logger({
-        category: "Init",
-        message: `Launching local browser in ${headless ? "headless" : "headed"} mode`,
-        level: 0
+        category: "init",
+        message: "launching local browser",
+        level: 0,
+        auxiliary: {
+          headless: {
+            value: headless.toString(),
+            type: "boolean"
+          }
+        }
       });
       const tmpDir = import_fs2.default.mkdtempSync(`/tmp/pwtest`);
       import_fs2.default.mkdirSync(`${tmpDir}/userdir/Default`, { recursive: true });
@@ -2603,8 +3351,8 @@ Live debug accessible here: ${debugUrl}.`,
         }
       );
       logger({
-        category: "Init",
-        message: "Local browser started successfully."
+        category: "init",
+        message: "local browser started successfully."
       });
       yield applyStealthScripts(context);
       return { context };
@@ -2658,7 +3406,7 @@ var Stagehand = class {
     this.is_processing_browserbase_logs = false;
     this.externalLogger = logger;
     this.logger = this.log.bind(this);
-    this.enableCaching = enableCaching != null ? enableCaching : false;
+    this.enableCaching = enableCaching != null ? enableCaching : process.env.ENABLE_CACHING && process.env.ENABLE_CACHING === "true";
     this.llmProvider = llmProvider || new LLMProvider(this.logger, this.enableCaching);
     this.env = env;
     this.observations = {};
@@ -2717,32 +3465,7 @@ var Stagehand = class {
         yield this.page.setViewportSize({ width: 1280, height: 720 });
       }
       yield this.context.addInitScript({
-        path: import_path2.default.join(__dirname, "..", "dist", "dom", "build", "xpathUtils.js"),
-        content: import_fs2.default.readFileSync(
-          import_path2.default.join(__dirname, "..", "dist", "dom", "build", "xpathUtils.js"),
-          "utf8"
-        )
-      });
-      yield this.context.addInitScript({
-        path: import_path2.default.join(__dirname, "..", "dist", "dom", "build", "process.js"),
-        content: import_fs2.default.readFileSync(
-          import_path2.default.join(__dirname, "..", "dist", "dom", "build", "process.js"),
-          "utf8"
-        )
-      });
-      yield this.context.addInitScript({
-        path: import_path2.default.join(__dirname, "..", "dist", "dom", "build", "utils.js"),
-        content: import_fs2.default.readFileSync(
-          import_path2.default.join(__dirname, "..", "dist", "dom", "build", "utils.js"),
-          "utf8"
-        )
-      });
-      yield this.context.addInitScript({
-        path: import_path2.default.join(__dirname, "..", "dist", "dom", "build", "debug.js"),
-        content: import_fs2.default.readFileSync(
-          import_path2.default.join(__dirname, "..", "dist", "dom", "build", "debug.js"),
-          "utf8"
-        )
+        content: scriptContent
       });
       return { debugUrl, sessionUrl };
     });
@@ -2763,52 +3486,21 @@ var Stagehand = class {
         yield this.page.setViewportSize({ width: 1280, height: 720 });
       }
       yield this.context.addInitScript({
-        path: import_path2.default.join(__dirname, "..", "dist", "dom", "build", "xpathUtils.js"),
-        content: import_fs2.default.readFileSync(
-          import_path2.default.join(__dirname, "..", "dist", "dom", "build", "xpathUtils.js"),
-          "utf8"
-        )
-      });
-      yield this.context.addInitScript({
-        path: import_path2.default.join(__dirname, "..", "dist", "dom", "build", "process.js"),
-        content: import_fs2.default.readFileSync(
-          import_path2.default.join(__dirname, "..", "dist", "dom", "build", "process.js"),
-          "utf8"
-        )
-      });
-      yield this.context.addInitScript({
-        path: import_path2.default.join(__dirname, "..", "dist", "dom", "build", "utils.js"),
-        content: import_fs2.default.readFileSync(
-          import_path2.default.join(__dirname, "..", "dist", "dom", "build", "utils.js"),
-          "utf8"
-        )
-      });
-      yield this.context.addInitScript({
-        path: import_path2.default.join(__dirname, "..", "dist", "dom", "build", "debug.js"),
-        content: import_fs2.default.readFileSync(
-          import_path2.default.join(__dirname, "..", "dist", "dom", "build", "debug.js"),
-          "utf8"
-        )
+        content: scriptContent
       });
       return { context: this.context };
     });
   }
-  log({
-    message,
-    category,
-    level
-  }) {
-    const logObj = { category, message, level };
+  log(logObj) {
     logObj.level = logObj.level || 1;
     if (this.externalLogger) {
       this.externalLogger(logObj);
     } else {
-      const categoryString = logObj.category ? `:${logObj.category}` : "";
-      const logMessage = `[stagehand${categoryString}] ${logObj.message}`;
+      const logMessage = logLineToString(logObj);
       console.log(logMessage);
     }
     this.pending_logs_to_send_to_browserbase.push(__spreadProps(__spreadValues({}, logObj), {
-      id: Math.random().toString(36).substring(2, 15)
+      id: (0, import_crypto2.randomUUID)()
     }));
     this._run_browserbase_log_processing_cycle();
   }
@@ -2833,7 +3525,7 @@ var Stagehand = class {
       }
       if (this.verbose >= logObj.level) {
         yield this.page.evaluate((logObj2) => {
-          const logMessage = `[stagehand${logObj2.category ? `:${logObj2.category}` : ""}] ${logObj2.message}`;
+          const logMessage = logLineToString(logObj2);
           if (logObj2.message.toLowerCase().includes("trace") || logObj2.message.toLowerCase().includes("error:")) {
             console.error(logMessage);
           } else {
@@ -2857,8 +3549,14 @@ var Stagehand = class {
           timeoutHandle = setTimeout(() => {
             this.log({
               category: "dom",
-              message: `DOM settle timeout of ${timeout}ms exceeded, continuing anyway`,
-              level: 1
+              message: "DOM settle timeout exceeded, continuing anyway",
+              level: 1,
+              auxiliary: {
+                timeout_ms: {
+                  value: timeout.toString(),
+                  type: "integer"
+                }
+              }
             });
             resolve();
           }, timeout);
@@ -2887,9 +3585,18 @@ var Stagehand = class {
       } catch (e) {
         this.log({
           category: "dom",
-          message: `Error in waitForSettledDom: ${e.message}
-Trace: ${e.stack}`,
-          level: 1
+          message: "Error in waitForSettledDom",
+          level: 1,
+          auxiliary: {
+            error: {
+              value: e.message,
+              type: "string"
+            },
+            trace: {
+              value: e.stack,
+              type: "string"
+            }
+          }
         });
       }
     });
@@ -2912,9 +3619,18 @@ Trace: ${e.stack}`,
       } catch (e) {
         this.log({
           category: "dom",
-          message: `Error in startDomDebug: ${e.message}
-Trace: ${e.stack}`,
-          level: 1
+          message: "Error in startDomDebug",
+          level: 1,
+          auxiliary: {
+            error: {
+              value: e.message,
+              type: "string"
+            },
+            trace: {
+              value: e.stack,
+              type: "string"
+            }
+          }
         });
       }
     });
@@ -2948,8 +3664,14 @@ Trace: ${e.stack}`,
     }) {
       this.log({
         category: "extraction",
-        message: `starting extraction '${instruction}'`,
-        level: 1
+        message: "starting extraction",
+        level: 1,
+        auxiliary: {
+          instruction: {
+            value: instruction,
+            type: "string"
+          }
+        }
       });
       yield this._waitForSettledDom(domSettleTimeoutMs);
       yield this.startDomDebug();
@@ -2959,8 +3681,22 @@ Trace: ${e.stack}`,
       );
       this.log({
         category: "extraction",
-        message: `received output from processDom. Current chunk index: ${chunk}, Number of chunks left: ${chunks.length - chunksSeen.length}`,
-        level: 1
+        message: "received output from processDom.",
+        level: 1,
+        auxiliary: {
+          chunk: {
+            value: chunk.toString(),
+            type: "integer"
+          },
+          chunks_left: {
+            value: (chunks.length - chunksSeen.length).toString(),
+            type: "integer"
+          },
+          chunks_total: {
+            value: chunks.length.toString(),
+            type: "integer"
+          }
+        }
       });
       const extractionResponse = yield extract({
         instruction,
@@ -2982,22 +3718,40 @@ Trace: ${e.stack}`,
       yield this.cleanupDomDebug();
       this.log({
         category: "extraction",
-        message: `received extraction response: ${JSON.stringify(extractionResponse)}`,
-        level: 1
+        message: "received extraction response",
+        level: 1,
+        auxiliary: {
+          extraction_response: {
+            value: JSON.stringify(extractionResponse),
+            type: "object"
+          }
+        }
       });
       chunksSeen.push(chunk);
       if (completed || chunksSeen.length === chunks.length) {
         this.log({
           category: "extraction",
-          message: `response: ${JSON.stringify(extractionResponse)}`,
-          level: 1
+          message: "got response",
+          level: 1,
+          auxiliary: {
+            extraction_response: {
+              value: JSON.stringify(extractionResponse),
+              type: "object"
+            }
+          }
         });
         return output;
       } else {
         this.log({
           category: "extraction",
-          message: `continuing extraction, progress: '${newProgress}'`,
-          level: 1
+          message: "continuing extraction",
+          level: 1,
+          auxiliary: {
+            extraction_response: {
+              value: JSON.stringify(extractionResponse),
+              type: "object"
+            }
+          }
         });
         yield this._waitForSettledDom(domSettleTimeoutMs);
         return this._extract({
@@ -3027,8 +3781,14 @@ Trace: ${e.stack}`,
       const model = modelName != null ? modelName : this.defaultModelName;
       this.log({
         category: "observation",
-        message: `starting observation: ${instruction}`,
-        level: 1
+        message: "starting observation",
+        level: 1,
+        auxiliary: {
+          instruction: {
+            value: instruction,
+            type: "string"
+          }
+        }
       });
       yield this._waitForSettledDom(domSettleTimeoutMs);
       yield this.startDomDebug();
@@ -3041,14 +3801,21 @@ Trace: ${e.stack}`,
         if (!modelsWithVision.includes(model)) {
           this.log({
             category: "observation",
-            message: `${model} does not support vision. Skipping vision processing.`,
-            level: 1
+            message: "Model does not support vision. Skipping vision processing.",
+            level: 1,
+            auxiliary: {
+              model: {
+                value: model,
+                type: "string"
+              }
+            }
           });
         } else {
           const screenshotService = new ScreenshotService(
             this.page,
             selectorMap,
-            this.verbose
+            this.verbose,
+            this.externalLogger
           );
           annotatedScreenshot = yield screenshotService.getAnnotatedScreenshot(fullPage);
           outputString = "n/a. use the image to find the elements.";
@@ -3074,8 +3841,14 @@ Trace: ${e.stack}`,
       this._recordObservation(instruction, elementsWithSelectors);
       this.log({
         category: "observation",
-        message: `found element ${JSON.stringify(elementsWithSelectors)}`,
-        level: 1
+        message: "found elements",
+        level: 1,
+        auxiliary: {
+          elements: {
+            value: JSON.stringify(elementsWithSelectors),
+            type: "object"
+          }
+        }
       });
       yield this._recordObservation(instruction, elementsWithSelectors);
       return elementsWithSelectors;
@@ -3091,9 +3864,20 @@ Trace: ${e.stack}`,
     }) {
       useVision = useVision != null ? useVision : "fallback";
       const requestId = Math.random().toString(36).substring(2);
-      this.logger({
+      this.log({
         category: "act",
-        message: `Running act with action: ${action}, requestId: ${requestId}`
+        message: "running act",
+        level: 1,
+        auxiliary: {
+          action: {
+            value: action,
+            type: "string"
+          },
+          requestId: {
+            value: requestId,
+            type: "string"
+          }
+        }
       });
       if (variables) {
         this.variables = __spreadValues(__spreadValues({}, this.variables), variables);
@@ -3110,10 +3894,20 @@ Trace: ${e.stack}`,
         skipActionCacheForThisStep: false,
         domSettleTimeoutMs
       }).catch((e) => {
-        this.logger({
+        this.log({
           category: "act",
-          message: `Error acting: ${e.message}
-Trace: ${e.stack}`
+          message: "error acting",
+          level: 1,
+          auxiliary: {
+            error: {
+              value: e.message,
+              type: "string"
+            },
+            trace: {
+              value: e.stack,
+              type: "string"
+            }
+          }
         });
         return {
           success: false,
@@ -3133,7 +3927,18 @@ Trace: ${e.stack}`
       const requestId = Math.random().toString(36).substring(2);
       this.logger({
         category: "extract",
-        message: `Running extract with instruction: ${instruction}, requestId: ${requestId}`
+        message: "running extract",
+        level: 1,
+        auxiliary: {
+          instruction: {
+            value: instruction,
+            type: "string"
+          },
+          requestId: {
+            value: requestId,
+            type: "string"
+          }
+        }
       });
       return this._extract({
         instruction,
@@ -3144,8 +3949,18 @@ Trace: ${e.stack}`
       }).catch((e) => {
         this.logger({
           category: "extract",
-          message: `Internal error: Error extracting: ${e.message}
-Trace: ${e.stack}`
+          message: "error extracting",
+          level: 1,
+          auxiliary: {
+            error: {
+              value: e.message,
+              type: "string"
+            },
+            trace: {
+              value: e.stack,
+              type: "string"
+            }
+          }
         });
         if (this.enableCaching) {
           this.llmProvider.cleanRequestCache(requestId);
@@ -3160,7 +3975,18 @@ Trace: ${e.stack}`
       const requestId = Math.random().toString(36).substring(2);
       this.logger({
         category: "observe",
-        message: `Running observe with instruction: ${options == null ? void 0 : options.instruction}, requestId: ${requestId}`
+        message: "running observe",
+        level: 1,
+        auxiliary: {
+          instruction: {
+            value: options == null ? void 0 : options.instruction,
+            type: "string"
+          },
+          requestId: {
+            value: requestId,
+            type: "string"
+          }
+        }
       });
       return this._observe({
         instruction: (_a = options == null ? void 0 : options.instruction) != null ? _a : "Find actions that can be performed on this page.",
@@ -3172,8 +3998,26 @@ Trace: ${e.stack}`
       }).catch((e) => {
         this.logger({
           category: "observe",
-          message: `Error observing: ${e.message}
-Trace: ${e.stack}`
+          message: "error observing",
+          level: 1,
+          auxiliary: {
+            error: {
+              value: e.message,
+              type: "string"
+            },
+            trace: {
+              value: e.stack,
+              type: "string"
+            },
+            requestId: {
+              value: requestId,
+              type: "string"
+            },
+            instruction: {
+              value: options == null ? void 0 : options.instruction,
+              type: "string"
+            }
+          }
         });
         if (this.enableCaching) {
           this.llmProvider.cleanRequestCache(requestId);