@browserbasehq/stagehand 1.0.1

package/dist/index.js

@@ -0,0 +1,1970 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  Stagehand: () => Stagehand
+});
+module.exports = __toCommonJS(lib_exports);
+var import_test = require("@playwright/test");
+var import_crypto = __toESM(require("crypto"));
+var import_fs2 = __toESM(require("fs"));
+
+// lib/prompt.ts
+var actSystemPrompt = `
+# Instructions
+You are a browser automation assistant. Your job is to accomplish the user's goal across multiple model calls.
+
+You are given:
+1. the user's overall goal
+2. the steps that you've taken so far
+3. a list of active DOM elements in this chunk to consider to get closer to the goal. 
+
+You have 2 tools that you can call: doAction, and skipSection. Do action only performs Playwright actions. Do not perform any other actions.
+
+Note: If there is a popup on the page for cookies or advertising that has nothing to do with the goal, try to close it first before proceeding. As this can block the goal from being completed.
+
+Also, verify if the goal has been accomplished already. Do this by checking if the goal has been accomplished based on the previous steps completed, the current page DOM elements and the current page URL / starting page URL. If it has, set completed to true and finish the task.
+
+Do exactly what the user's goal is. Do not exceed the scope of the goal.
+`;
+var verifyActCompletionSystemPrompt = `
+You are a browser automation assistant. The job has given you a goal and a list of steps that have been taken so far. Your job is to determine if the user's goal has been completed based on the provided information.
+
+# Input
+You will receive:
+1. The user's goal: A clear description of what the user wants to achieve.
+2. Steps taken so far: A list of actions that have been performed up to this point.
+3. An image of the current page
+
+# Your Task
+Analyze the provided information to determine if the user's goal has been fully completed.
+
+# Output
+Return a boolean value:
+- true: If the goal has been definitively completed based on the steps taken and the current page.
+- false: If the goal has not been completed or if there's any uncertainty about its completion.
+
+# Important Considerations
+- False positives are okay. False negatives are not okay.
+- Look for evidence of errors on the page or something having gone wrong in completing the goal. If one does not exist, return true.
+`;
+function buildVerifyActCompletionSystemPrompt() {
+  return {
+    role: "system",
+    content: verifyActCompletionSystemPrompt
+  };
+}
+function buildVerifyActCompletionUserPrompt(goal, steps = "None", domElements) {
+  let actUserPrompt = `
+# My Goal
+${goal}
+
+# Steps You've Taken So Far
+${steps}
+`;
+  if (domElements) {
+    actUserPrompt += `
+# Active DOM Elements on the current page
+${domElements}
+`;
+  }
+  return {
+    role: "user",
+    content: actUserPrompt
+  };
+}
+function buildActSystemPrompt() {
+  return {
+    role: "system",
+    content: actSystemPrompt
+  };
+}
+function buildActUserPrompt(action, steps = "None", domElements) {
+  const actUserPrompt = `
+# My Goal
+${action}
+
+# Steps You've Taken So Far
+${steps}
+
+# Current Active Dom Elements
+${domElements}
+`;
+  return {
+    role: "user",
+    content: actUserPrompt
+  };
+}
+var actTools = [
+  {
+    type: "function",
+    function: {
+      name: "doAction",
+      description: "execute the next playwright step that directly accomplishes the goal",
+      parameters: {
+        type: "object",
+        required: ["method", "element", "args", "step", "completed"],
+        properties: {
+          method: {
+            type: "string",
+            description: "The playwright function to call."
+          },
+          element: {
+            type: "number",
+            description: "The element number to act on"
+          },
+          args: {
+            type: "array",
+            description: "The required arguments",
+            items: {
+              type: "string",
+              description: "The argument to pass to the function"
+            }
+          },
+          step: {
+            type: "string",
+            description: "human readable description of the step that is taken in the past tense. Please be very detailed."
+          },
+          why: {
+            type: "string",
+            description: "why is this step taken? how does it advance the goal?"
+          },
+          completed: {
+            type: "boolean",
+            description: "true if the goal should be accomplished after this step"
+          }
+        }
+      }
+    }
+  },
+  {
+    type: "function",
+    function: {
+      name: "skipSection",
+      description: "skips this area of the webpage because the current goal cannot be accomplished here",
+      parameters: {
+        type: "object",
+        properties: {
+          reason: {
+            type: "string",
+            description: "reason that no action is taken"
+          }
+        }
+      }
+    }
+  }
+];
+var extractSystemPrompt = `You are extracting content on behalf of a user. You will be given:
+1. An instruction
+2. A list of DOM elements to extract from
+
+Print the exact text from the DOM elements with all symbols, characters, and endlines as is.
+Print null or an empty string if no new information is found.
+
+ONLY print the content using the print_extracted_data tool provided.
+ONLY print the content using the print_extracted_data tool provided.
+`;
+function buildExtractSystemPrompt() {
+  const content = extractSystemPrompt.replace(/\s+/g, " ");
+  return {
+    role: "system",
+    content
+  };
+}
+function buildExtractUserPrompt(instruction, domElements) {
+  return {
+    role: "user",
+    content: `Instruction: ${instruction}
+DOM: ${domElements}
+
+ONLY print the content using the print_extracted_data tool provided.
+ONLY print the content using the print_extracted_data tool provided.`
+  };
+}
+var refineSystemPrompt = `You are tasked with refining and filtering information for the final output based on newly extracted and previously extracted content. Your responsibilities are:
+1. Remove exact duplicates for elements in arrays and objects.
+2. For text fields, append or update relevant text if the new content is an extension, replacement, or continuation.
+3. For non-text fields (e.g., numbers, booleans), update with new values if they differ.
+4. Add any completely new fields or objects.
+
+Return the updated content that includes both the previous content and the new, non-duplicate, or extended information.`;
+function buildRefineSystemPrompt() {
+  return {
+    role: "system",
+    content: refineSystemPrompt
+  };
+}
+function buildRefineUserPrompt(instruction, previouslyExtractedContent, newlyExtractedContent) {
+  return {
+    role: "user",
+    content: `Instruction: ${instruction}
+Previously extracted content: ${JSON.stringify(previouslyExtractedContent, null, 2)}
+Newly extracted content: ${JSON.stringify(newlyExtractedContent, null, 2)}
+Refined content:`
+  };
+}
+var metadataSystemPrompt = `You are an AI assistant tasked with evaluating the progress and completion status of an extraction task.
+Analyze the extraction response and determine if the task is completed or if more information is needed.
+
+Strictly abide by the following criteria:
+1. If you are certain that the instruction is completed, set the completion status to true, even if there are still chunks left.
+2. If there could still be more information to extract and there are still chunks left, set the completion status to false.`;
+function buildMetadataSystemPrompt() {
+  return {
+    role: "system",
+    content: metadataSystemPrompt
+  };
+}
+function buildMetadataPrompt(instruction, extractionResponse, chunksSeen, chunksTotal) {
+  return {
+    role: "user",
+    content: `Instruction: ${instruction}
+Extracted content: ${JSON.stringify(extractionResponse, null, 2)}
+Chunks seen: ${chunksSeen}
+Chunks total: ${chunksTotal}`
+  };
+}
+var observeSystemPrompt = `
+You are helping the user automate the browser by finding elements based on what the user wants to observe in the page.
+You will be given:
+1. a instruction of elements to observe
+2. a numbered list of possible elements or an annotated image of the page
+
+Return an array of elements that match the instruction.
+`;
+function buildObserveSystemPrompt() {
+  const content = observeSystemPrompt.replace(/\s+/g, " ");
+  return {
+    role: "system",
+    content
+  };
+}
+function buildObserveUserMessage(instruction, domElements) {
+  return {
+    role: "user",
+    content: `instruction: ${instruction}
+DOM: ${domElements}`
+  };
+}
+
+// lib/inference.ts
+var import_zod = require("zod");
+
+// lib/llm/LLMClient.ts
+var modelsWithVision = [
+  "gpt-4o",
+  "gpt-4o-mini",
+  "claude-3-5-sonnet-latest",
+  "claude-3-5-sonnet-20240620",
+  "gpt-4o-2024-08-06"
+];
+var AnnotatedScreenshotText = "This is a screenshot of the current page state with the elements annotated on it. Each element id is annotated with a number to the top left of it. Duplicate annotations at the same location are under each other vertically.";
+
+// lib/inference.ts
+function verifyActCompletion(_0) {
+  return __async(this, arguments, function* ({
+    goal,
+    steps,
+    llmProvider,
+    modelName,
+    screenshot,
+    domElements,
+    logger
+  }) {
+    const llmClient = llmProvider.getClient(modelName);
+    const messages = [
+      buildVerifyActCompletionSystemPrompt(),
+      buildVerifyActCompletionUserPrompt(goal, steps, domElements)
+    ];
+    const response = yield llmClient.createChatCompletion({
+      model: modelName,
+      messages,
+      temperature: 0.1,
+      top_p: 1,
+      frequency_penalty: 0,
+      presence_penalty: 0,
+      image: screenshot ? {
+        buffer: screenshot,
+        description: "This is a screenshot of the whole visible page."
+      } : void 0,
+      response_model: {
+        name: "Verification",
+        schema: import_zod.z.object({
+          completed: import_zod.z.boolean().describe("true if the goal is accomplished")
+        })
+      }
+    });
+    if (!response || typeof response !== "object") {
+      logger({
+        category: "VerifyAct",
+        message: "Unexpected response format: " + JSON.stringify(response)
+      });
+      return false;
+    }
+    if (response.completed === void 0) {
+      logger({
+        category: "VerifyAct",
+        message: "Missing 'completed' field in response"
+      });
+      return false;
+    }
+    return response.completed;
+  });
+}
+function act(_0) {
+  return __async(this, arguments, function* ({
+    action,
+    domElements,
+    steps,
+    llmProvider,
+    modelName,
+    screenshot,
+    retries = 0,
+    logger
+  }) {
+    const llmClient = llmProvider.getClient(modelName);
+    const messages = [
+      buildActSystemPrompt(),
+      buildActUserPrompt(action, steps, domElements)
+    ];
+    const response = yield llmClient.createChatCompletion({
+      model: modelName,
+      messages,
+      temperature: 0.1,
+      top_p: 1,
+      frequency_penalty: 0,
+      presence_penalty: 0,
+      tool_choice: "auto",
+      tools: actTools,
+      image: screenshot ? { buffer: screenshot, description: AnnotatedScreenshotText } : void 0
+    });
+    const toolCalls = response.choices[0].message.tool_calls;
+    if (toolCalls && toolCalls.length > 0) {
+      if (toolCalls[0].function.name === "skipSection") {
+        return null;
+      }
+      return JSON.parse(toolCalls[0].function.arguments);
+    } else {
+      if (retries >= 2) {
+        logger({
+          category: "Act",
+          message: "No tool calls found in response"
+        });
+        return null;
+      }
+      return act({
+        action,
+        domElements,
+        steps,
+        llmProvider,
+        modelName,
+        retries: retries + 1,
+        logger
+      });
+    }
+  });
+}
+function extract(_0) {
+  return __async(this, arguments, function* ({
+    instruction,
+    progress,
+    previouslyExtractedContent,
+    domElements,
+    schema,
+    llmProvider,
+    modelName,
+    chunksSeen,
+    chunksTotal
+  }) {
+    const llmClient = llmProvider.getClient(modelName);
+    const extractionResponse = yield llmClient.createChatCompletion({
+      model: modelName,
+      messages: [
+        buildExtractSystemPrompt(),
+        buildExtractUserPrompt(instruction, domElements)
+      ],
+      response_model: {
+        schema,
+        name: "Extraction"
+      },
+      temperature: 0.1,
+      top_p: 1,
+      frequency_penalty: 0,
+      presence_penalty: 0
+    });
+    const refinedResponse = yield llmClient.createChatCompletion({
+      model: modelName,
+      messages: [
+        buildRefineSystemPrompt(),
+        buildRefineUserPrompt(
+          instruction,
+          previouslyExtractedContent,
+          extractionResponse
+        )
+      ],
+      response_model: {
+        schema,
+        name: "RefinedExtraction"
+      },
+      temperature: 0.1,
+      top_p: 1,
+      frequency_penalty: 0,
+      presence_penalty: 0
+    });
+    const metadataSchema = import_zod.z.object({
+      progress: import_zod.z.string().describe(
+        "progress of what has been extracted so far, as concise as possible"
+      ),
+      completed: import_zod.z.boolean().describe(
+        "true if the goal is now accomplished. Use this conservatively, only when you are sure that the goal has been completed."
+      )
+    });
+    const metadataResponse = yield llmClient.createChatCompletion({
+      model: modelName,
+      messages: [
+        buildMetadataSystemPrompt(),
+        buildMetadataPrompt(
+          instruction,
+          refinedResponse,
+          chunksSeen,
+          chunksTotal
+        )
+      ],
+      response_model: {
+        name: "Metadata",
+        schema: metadataSchema
+      },
+      temperature: 0.1,
+      top_p: 1,
+      frequency_penalty: 0,
+      presence_penalty: 0
+    });
+    refinedResponse.metadata = metadataResponse;
+    return refinedResponse;
+  });
+}
+function observe(_0) {
+  return __async(this, arguments, function* ({
+    instruction,
+    domElements,
+    llmProvider,
+    modelName,
+    image
+  }) {
+    const observeSchema = import_zod.z.object({
+      elements: import_zod.z.array(
+        import_zod.z.object({
+          elementId: import_zod.z.number().describe("the number of the element"),
+          description: import_zod.z.string().describe(
+            "a description of the element and what it is relevant for"
+          )
+        })
+      ).describe("an array of elements that match the instruction")
+    });
+    const llmClient = llmProvider.getClient(modelName);
+    const observationResponse = yield llmClient.createChatCompletion({
+      model: modelName,
+      messages: [
+        buildObserveSystemPrompt(),
+        buildObserveUserMessage(instruction, domElements)
+      ],
+      image: image ? { buffer: image, description: AnnotatedScreenshotText } : void 0,
+      response_model: {
+        schema: observeSchema,
+        name: "Observation"
+      },
+      temperature: 0.1,
+      top_p: 1,
+      frequency_penalty: 0,
+      presence_penalty: 0
+    });
+    if (!observationResponse) {
+      throw new Error("no response when finding a selector");
+    }
+    return observationResponse;
+  });
+}
+
+// lib/llm/OpenAIClient.ts
+var import_openai = __toESM(require("openai"));
+var import_zod2 = require("openai/helpers/zod");
+var OpenAIClient = class {
+  constructor(logger) {
+    this.client = new import_openai.default();
+    this.logger = logger;
+  }
+  createChatCompletion(options) {
+    return __async(this, null, function* () {
+      if (options.image) {
+        const screenshotMessage = {
+          role: "user",
+          content: [
+            {
+              type: "image_url",
+              image_url: {
+                url: `data:image/jpeg;base64,${options.image.buffer.toString("base64")}`
+              }
+            },
+            ...options.image.description ? [{ type: "text", text: options.image.description }] : []
+          ]
+        };
+        options.messages = [...options.messages, screenshotMessage];
+      }
+      const _a = options, { image, response_model } = _a, openAiOptions = __objRest(_a, ["image", "response_model"]);
+      let responseFormat = void 0;
+      if (options.response_model) {
+        responseFormat = (0, import_zod2.zodResponseFormat)(
+          options.response_model.schema,
+          options.response_model.name
+        );
+      }
+      const response = yield this.client.chat.completions.create(__spreadProps(__spreadValues({}, openAiOptions), {
+        response_format: responseFormat
+      }));
+      if (response_model) {
+        const extractedData = response.choices[0].message.content;
+        const parsedData = JSON.parse(extractedData);
+        return __spreadValues({}, parsedData);
+      }
+      return response;
+    });
+  }
+};
+
+// lib/llm/AnthropicClient.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"));
+var import_zod_to_json_schema = require("zod-to-json-schema");
+var AnthropicClient = class {
+  constructor(logger) {
+    this.client = new import_sdk.default({
+      apiKey: process.env.ANTHROPIC_API_KEY
+      // Make sure to set this environment variable
+    });
+    this.logger = logger;
+  }
+  createChatCompletion(options) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g;
+      const systemMessage = options.messages.find((msg) => msg.role === "system");
+      const userMessages = options.messages.filter(
+        (msg) => msg.role !== "system"
+      );
+      if (options.image) {
+        const screenshotMessage = {
+          role: "user",
+          content: [
+            {
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: "image/jpeg",
+                data: options.image.buffer.toString("base64")
+              }
+            },
+            ...options.image.description ? [{ type: "text", text: options.image.description }] : []
+          ]
+        };
+        options.messages = [...options.messages, screenshotMessage];
+      }
+      let anthropicTools = (_a = options.tools) == null ? void 0 : _a.map((tool) => {
+        if (tool.type === "function") {
+          return {
+            name: tool.function.name,
+            description: tool.function.description,
+            input_schema: {
+              type: "object",
+              properties: tool.function.parameters.properties,
+              required: tool.function.parameters.required
+            }
+          };
+        }
+        return tool;
+      });
+      let toolDefinition;
+      if (options.response_model) {
+        const jsonSchema = (0, import_zod_to_json_schema.zodToJsonSchema)(options.response_model.schema);
+        const schemaProperties = ((_c = (_b = jsonSchema.definitions) == null ? void 0 : _b.MySchema) == null ? void 0 : _c.properties) || jsonSchema.properties;
+        const schemaRequired = ((_e = (_d = jsonSchema.definitions) == null ? void 0 : _d.MySchema) == null ? void 0 : _e.required) || jsonSchema.required;
+        toolDefinition = {
+          name: "print_extracted_data",
+          description: "Prints the extracted data based on the provided schema.",
+          input_schema: {
+            type: "object",
+            properties: schemaProperties,
+            required: schemaRequired
+          }
+        };
+      }
+      if (toolDefinition) {
+        anthropicTools = anthropicTools != null ? anthropicTools : [];
+        anthropicTools.push(toolDefinition);
+      }
+      const response = yield this.client.messages.create({
+        model: options.model,
+        max_tokens: options.max_tokens || 1500,
+        messages: userMessages.map((msg) => ({
+          role: msg.role,
+          content: msg.content
+        })),
+        tools: anthropicTools,
+        system: systemMessage == null ? void 0 : systemMessage.content,
+        temperature: options.temperature
+      });
+      const transformedResponse = {
+        id: response.id,
+        object: "chat.completion",
+        created: Date.now(),
+        model: response.model,
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: "assistant",
+              content: ((_f = response.content.find((c) => c.type === "text")) == null ? void 0 : _f.text) || null,
+              tool_calls: response.content.filter((c) => c.type === "tool_use").map((toolUse) => ({
+                id: toolUse.id,
+                type: "function",
+                function: {
+                  name: toolUse.name,
+                  arguments: JSON.stringify(toolUse.input)
+                }
+              }))
+            },
+            finish_reason: response.stop_reason
+          }
+        ],
+        usage: {
+          prompt_tokens: response.usage.input_tokens,
+          completion_tokens: response.usage.output_tokens,
+          total_tokens: response.usage.input_tokens + response.usage.output_tokens
+        }
+      };
+      this.logger({
+        category: "Anthropic",
+        message: "Transformed response: " + JSON.stringify(transformedResponse)
+      });
+      if (options.response_model) {
+        const toolUse = response.content.find((c) => c.type === "tool_use");
+        if (toolUse && "input" in toolUse) {
+          return toolUse.input;
+        } else {
+          if (!options.retries || options.retries < 2) {
+            return this.createChatCompletion(__spreadProps(__spreadValues({}, options), {
+              retries: ((_g = options.retries) != null ? _g : 0) + 1
+            }));
+          }
+          throw new Error(
+            "Extraction failed: No tool use with input in response"
+          );
+        }
+      }
+      return transformedResponse;
+    });
+  }
+};
+
+// lib/llm/LLMProvider.ts
+var LLMProvider = class {
+  constructor(logger) {
+    this.modelToProviderMap = {
+      "gpt-4o": "openai",
+      "gpt-4o-mini": "openai",
+      "gpt-4o-2024-08-06": "openai",
+      "claude-3-5-sonnet-latest": "anthropic",
+      "claude-3-5-sonnet-20240620": "anthropic",
+      "claude-3-5-sonnet-20241022": "anthropic"
+    };
+    this.logger = logger;
+  }
+  getClient(modelName) {
+    const provider = this.modelToProviderMap[modelName];
+    if (!provider) {
+      throw new Error(`Unsupported model: ${modelName}`);
+    }
+    switch (provider) {
+      case "openai":
+        return new OpenAIClient(this.logger);
+      case "anthropic":
+        return new AnthropicClient(this.logger);
+      default:
+        throw new Error(`Unsupported provider: ${provider}`);
+    }
+  }
+};
+
+// lib/index.ts
+var import_path2 = __toESM(require("path"));
+
+// lib/browserbase.ts
+var Browserbase = class {
+  createSession() {
+    return __async(this, null, function* () {
+      if (!process.env.BROWSERBASE_API_KEY || !process.env.BROWSERBASE_PROJECT_ID) {
+        throw new Error(
+          "BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID must be set"
+        );
+      }
+      const response = yield fetch(`https://www.browserbase.com/v1/sessions`, {
+        method: "POST",
+        headers: {
+          "x-bb-api-key": `${process.env.BROWSERBASE_API_KEY}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          projectId: process.env.BROWSERBASE_PROJECT_ID
+        })
+      });
+      const json = yield response.json();
+      if (json.error) {
+        throw new Error(json.error);
+      }
+      return {
+        sessionId: json.id,
+        connectUrl: json.connectUrl
+      };
+    });
+  }
+  retrieveDebugConnectionURL(sessionId) {
+    return __async(this, null, function* () {
+      if (!process.env.BROWSERBASE_API_KEY) {
+        throw new Error("BROWSERBASE_API_KEY must be set");
+      }
+      const response = yield fetch(
+        `https://www.browserbase.com/v1/sessions/${sessionId}/debug`,
+        {
+          method: "GET",
+          headers: {
+            "x-bb-api-key": `${process.env.BROWSERBASE_API_KEY}`
+          }
+        }
+      );
+      const json = yield response.json();
+      return json.debuggerFullscreenUrl;
+    });
+  }
+};
+
+// 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) {
+    this.annotationBoxes = [];
+    this.numberPositions = [];
+    this.page = page;
+    this.selectorMap = selectorMap;
+    this.isDebugEnabled = isDebugEnabled;
+    this.verbose = verbose;
+  }
+  log({
+    category,
+    message,
+    level = 1
+  }) {
+    if (this.verbose >= level) {
+      const categoryString = category ? `:${category}` : "";
+      console.log(`[stagehand${categoryString}] ${message}`);
+    }
+  }
+  getScreenshot(fullpage = true, quality) {
+    return __async(this, null, function* () {
+      if (quality && (quality < 0 || quality > 100)) {
+        throw new Error("quality must be between 0 and 100");
+      }
+      return yield this.page.screenshot({
+        fullPage: fullpage,
+        quality,
+        type: "jpeg"
+      });
+    });
+  }
+  getScreenshotPixelCount(screenshot) {
+    return __async(this, null, function* () {
+      const image = (0, import_sharp.default)(screenshot);
+      const metadata = yield image.metadata();
+      if (!metadata.width || !metadata.height) {
+        this.log({
+          category: "Error",
+          message: "Unable to determine image dimensions.",
+          level: 0
+        });
+        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
+      });
+      return pixelCount;
+    });
+  }
+  getAnnotatedScreenshot(fullpage) {
+    return __async(this, null, function* () {
+      this.annotationBoxes = [];
+      this.numberPositions = [];
+      const screenshot = yield this.getScreenshot(fullpage);
+      const image = (0, import_sharp.default)(screenshot);
+      const { width, height } = yield image.metadata();
+      const svgAnnotations = yield Promise.all(
+        Object.entries(this.selectorMap).map(
+          (_0) => __async(this, [_0], function* ([id, selector]) {
+            return this.createElementAnnotation(id, selector);
+          })
+        )
+      );
+      const scrollPosition = yield this.page.evaluate(() => {
+        return {
+          scrollX: window.scrollX,
+          scrollY: window.scrollY
+        };
+      });
+      const svg = `
+      <svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg" style="position:absolute;left:${-scrollPosition.scrollX}px;top:${-scrollPosition.scrollY}px;">
+        ${svgAnnotations.join("")}
+      </svg>
+    `;
+      const annotatedScreenshot = yield image.composite([{ input: Buffer.from(svg), top: 0, left: 0 }]).toBuffer();
+      if (this.isDebugEnabled) {
+        yield _ScreenshotService.saveAndOpenScreenshot(annotatedScreenshot);
+      }
+      return annotatedScreenshot;
+    });
+  }
+  createElementAnnotation(id, selector) {
+    return __async(this, null, function* () {
+      try {
+        const element = yield this.page.locator(`xpath=${selector}`).first();
+        const box = yield element.boundingBox();
+        if (!box) {
+          this.log({
+            category: "Debug",
+            message: `No bounding box for element ${id}`,
+            level: 2
+          });
+          return "";
+        }
+        const scrollPosition = yield this.page.evaluate(() => ({
+          scrollX: window.scrollX,
+          scrollY: window.scrollY
+        }));
+        const adjustedBox = {
+          x: box.x + scrollPosition.scrollX,
+          y: box.y + scrollPosition.scrollY,
+          width: box.width,
+          height: box.height,
+          id
+        };
+        this.annotationBoxes.push(adjustedBox);
+        const numberPosition = this.findNonOverlappingNumberPosition(adjustedBox);
+        const circleRadius = 12;
+        return `
+        <rect x="${adjustedBox.x}" y="${adjustedBox.y}" width="${adjustedBox.width}" height="${adjustedBox.height}" 
+              fill="none" stroke="red" stroke-width="2" />
+        <circle cx="${numberPosition.x}" cy="${numberPosition.y}" r="${circleRadius}" fill="white" stroke="red" stroke-width="2" />
+        <text x="${numberPosition.x}" y="${numberPosition.y}" fill="red" font-size="16" font-weight="bold" 
+              text-anchor="middle" dominant-baseline="central">
+          ${id}
+        </text>
+      `;
+      } catch (error) {
+        this.log({
+          category: "Error",
+          message: `Failed to create annotation for element ${id}: ${error}`,
+          level: 0
+        });
+        return "";
+      }
+    });
+  }
+  findNonOverlappingNumberPosition(box) {
+    const circleRadius = 12;
+    let position = {
+      x: box.x - circleRadius,
+      y: box.y - circleRadius
+    };
+    let attempts = 0;
+    const maxAttempts = 10;
+    const offset = 5;
+    while (this.isNumberOverlapping(position) && attempts < maxAttempts) {
+      position.y += offset;
+      attempts++;
+    }
+    this.numberPositions.push(position);
+    return position;
+  }
+  isNumberOverlapping(position) {
+    const circleRadius = 12;
+    return this.numberPositions.some(
+      (existingPosition) => Math.sqrt(
+        Math.pow(position.x - existingPosition.x, 2) + Math.pow(position.y - existingPosition.y, 2)
+      ) < circleRadius * 2
+    );
+  }
+  static saveAndOpenScreenshot(screenshot) {
+    return __async(this, null, function* () {
+      const screenshotDir = import_path.default.join(process.cwd(), "screenshots");
+      if (!import_fs.default.existsSync(screenshotDir)) {
+        import_fs.default.mkdirSync(screenshotDir);
+      }
+      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}`);
+      if (process.platform === "win32") {
+        (0, import_child_process.exec)(`start ${filename}`);
+      } else if (process.platform === "darwin") {
+        (0, import_child_process.exec)(`open ${filename}`);
+      } else {
+        (0, import_child_process.exec)(`xdg-open ${filename}`);
+      }
+    });
+  }
+};
+
+// lib/index.ts
+require("dotenv").config({ path: ".env" });
+function getBrowser(env = "LOCAL", headless = false, logger) {
+  return __async(this, null, function* () {
+    if (env === "BROWSERBASE" && !process.env.BROWSERBASE_API_KEY) {
+      logger({
+        category: "Init",
+        message: "BROWSERBASE_API_KEY is required to use BROWSERBASE env. Defaulting to LOCAL.",
+        level: 0
+      });
+      env = "LOCAL";
+    }
+    if (env === "BROWSERBASE" && !process.env.BROWSERBASE_PROJECT_ID) {
+      logger({
+        category: "Init",
+        message: "BROWSERBASE_PROJECT_ID is required to use BROWSERBASE env. Defaulting to LOCAL.",
+        level: 0
+      });
+      env = "LOCAL";
+    }
+    if (env === "BROWSERBASE") {
+      let debugUrl = void 0;
+      let sessionUrl = void 0;
+      logger({
+        category: "Init",
+        message: "Connecting you to Browserbase...",
+        level: 0
+      });
+      const browserbase = new Browserbase();
+      const { sessionId, connectUrl } = yield browserbase.createSession();
+      const browser = yield import_test.chromium.connectOverCDP(connectUrl);
+      debugUrl = yield browserbase.retrieveDebugConnectionURL(sessionId);
+      sessionUrl = `https://www.browserbase.com/sessions/${sessionId}`;
+      logger({
+        category: "Init",
+        message: `Browserbase session started.
+
+Session Url: ${sessionUrl}
+
+Live debug accessible here: ${debugUrl}.`,
+        level: 0
+      });
+      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
+      });
+      const tmpDir = import_fs2.default.mkdtempSync(`/tmp/pwtest`);
+      import_fs2.default.mkdirSync(`${tmpDir}/userdir/Default`, { recursive: true });
+      const defaultPreferences = {
+        plugins: {
+          always_open_pdf_externally: true
+        }
+      };
+      import_fs2.default.writeFileSync(
+        `${tmpDir}/userdir/Default/Preferences`,
+        JSON.stringify(defaultPreferences)
+      );
+      const downloadsPath = `${process.cwd()}/downloads`;
+      import_fs2.default.mkdirSync(downloadsPath, { recursive: true });
+      const context = yield import_test.chromium.launchPersistentContext(
+        `${tmpDir}/userdir`,
+        {
+          acceptDownloads: true,
+          headless,
+          viewport: {
+            width: 1250,
+            height: 800
+          },
+          locale: "en-US",
+          timezoneId: "America/New_York",
+          deviceScaleFactor: 1,
+          args: [
+            "--enable-webgl",
+            "--use-gl=swiftshader",
+            "--enable-accelerated-2d-canvas",
+            "--disable-blink-features=AutomationControlled",
+            "--disable-web-security"
+          ],
+          bypassCSP: true,
+          userDataDir: "./user_data"
+        }
+      );
+      logger({
+        category: "Init",
+        message: "Local browser started successfully."
+      });
+      yield applyStealthScripts(context);
+      return { context };
+    }
+  });
+}
+function applyStealthScripts(context) {
+  return __async(this, null, function* () {
+    yield context.addInitScript(() => {
+      Object.defineProperty(navigator, "webdriver", {
+        get: () => void 0
+      });
+      Object.defineProperty(navigator, "languages", {
+        get: () => ["en-US", "en"]
+      });
+      Object.defineProperty(navigator, "plugins", {
+        get: () => [1, 2, 3, 4, 5]
+      });
+      delete window.__playwright;
+      delete window.__pw_manual;
+      delete window.__PW_inspect;
+      Object.defineProperty(navigator, "headless", {
+        get: () => false
+      });
+      const originalQuery = window.navigator.permissions.query;
+      window.navigator.permissions.query = (parameters) => parameters.name === "notifications" ? Promise.resolve({
+        state: Notification.permission
+      }) : originalQuery(parameters);
+    });
+  });
+}
+var Stagehand = class {
+  constructor({
+    env,
+    verbose = 0,
+    debugDom = false,
+    llmProvider,
+    headless = false,
+    logger,
+    domSettleTimeoutMs = 6e4
+  } = {
+    env: "BROWSERBASE"
+  }) {
+    // Logging
+    this.pending_logs_to_send_to_browserbase = [];
+    this.is_processing_browserbase_logs = false;
+    this.externalLogger = logger;
+    this.logger = this.log.bind(this);
+    this.llmProvider = llmProvider || new LLMProvider(this.logger);
+    this.env = env;
+    this.observations = {};
+    this.actions = {};
+    this.verbose = verbose;
+    this.debugDom = debugDom;
+    this.defaultModelName = "gpt-4o";
+    this.headless = headless;
+    this.domSettleTimeoutMs = domSettleTimeoutMs;
+  }
+  init() {
+    return __async(this, arguments, function* ({
+      modelName = "gpt-4o"
+    } = {}) {
+      const { context, debugUrl, sessionUrl } = yield getBrowser(
+        this.env,
+        this.headless,
+        this.logger
+      ).catch((e) => {
+        console.error("Error in init:", e);
+        return { context: void 0, debugUrl: void 0, sessionUrl: void 0 };
+      });
+      this.context = context;
+      this.page = context.pages()[0];
+      this.defaultModelName = modelName;
+      const originalGoto = this.page.goto.bind(this.page);
+      this.page.goto = (url, options) => __async(this, null, function* () {
+        const result = yield originalGoto(url, options);
+        yield this.page.waitForLoadState("domcontentloaded");
+        yield this._waitForSettledDom();
+        return result;
+      });
+      if (this.headless) {
+        yield this.page.setViewportSize({ width: 1280, height: 720 });
+      }
+      yield this.page.addInitScript({
+        path: import_path2.default.join(__dirname, "..", "dist", "dom", "build", "process.js")
+      });
+      yield this.page.addInitScript({
+        path: import_path2.default.join(__dirname, "..", "dist", "dom", "build", "utils.js")
+      });
+      yield this.page.addInitScript({
+        path: import_path2.default.join(__dirname, "..", "dist", "dom", "build", "debug.js")
+      });
+      return { debugUrl, sessionUrl };
+    });
+  }
+  log({
+    message,
+    category,
+    level
+  }) {
+    const logObj = { category, message, level };
+    logObj.level = logObj.level || 1;
+    if (this.externalLogger) {
+      this.externalLogger(logObj);
+    } else {
+      const categoryString = logObj.category ? `:${logObj.category}` : "";
+      const logMessage = `[stagehand${categoryString}] ${logObj.message}`;
+      console.log(logMessage);
+    }
+    this.pending_logs_to_send_to_browserbase.push(__spreadProps(__spreadValues({}, logObj), {
+      id: Math.random().toString(36).substring(2, 15)
+    }));
+    this._run_browserbase_log_processing_cycle();
+  }
+  _run_browserbase_log_processing_cycle() {
+    return __async(this, null, function* () {
+      if (this.is_processing_browserbase_logs) {
+        return;
+      }
+      this.is_processing_browserbase_logs = true;
+      const pending_logs = [...this.pending_logs_to_send_to_browserbase];
+      for (const logObj of pending_logs) {
+        yield this._log_to_browserbase(logObj);
+      }
+      this.is_processing_browserbase_logs = false;
+    });
+  }
+  _log_to_browserbase(logObj) {
+    return __async(this, null, function* () {
+      logObj.level = logObj.level || 1;
+      if (!this.page) {
+        return;
+      }
+      if (this.verbose >= logObj.level) {
+        yield this.page.evaluate((logObj2) => {
+          const logMessage = `[stagehand${logObj2.category ? `:${logObj2.category}` : ""}] ${logObj2.message}`;
+          if (logObj2.message.toLowerCase().includes("trace") || logObj2.message.toLowerCase().includes("error:")) {
+            console.error(logMessage);
+          } else {
+            console.log(logMessage);
+          }
+        }, logObj).then(() => {
+          this.pending_logs_to_send_to_browserbase = this.pending_logs_to_send_to_browserbase.filter(
+            (log) => log.id !== logObj.id
+          );
+        }).catch((e) => {
+        });
+      }
+    });
+  }
+  _waitForSettledDom(timeoutMs) {
+    return __async(this, null, function* () {
+      try {
+        const timeout = timeoutMs != null ? timeoutMs : this.domSettleTimeoutMs;
+        const timeoutPromise = new Promise((resolve) => {
+          setTimeout(() => {
+            console.warn(
+              `[stagehand:dom] DOM settle timeout of ${timeout}ms exceeded, continuing anyway`
+            );
+            this.log({
+              category: "dom",
+              message: `DOM settle timeout of ${timeout}ms exceeded, continuing anyway`,
+              level: 1
+            });
+            resolve();
+          }, timeout);
+        });
+        yield Promise.race([
+          (() => __async(this, null, function* () {
+            yield this.page.waitForSelector("body");
+            yield this.page.waitForLoadState("domcontentloaded");
+            yield this.page.evaluate(() => {
+              return new Promise((resolve) => {
+                if (typeof window.waitForDomSettle === "function") {
+                  window.waitForDomSettle().then(() => {
+                    resolve();
+                  });
+                } else {
+                  console.warn(
+                    "waitForDomSettle is not defined, considering DOM as settled"
+                  );
+                  resolve();
+                }
+              });
+            });
+          }))(),
+          timeoutPromise
+        ]);
+      } catch (e) {
+        this.log({
+          category: "dom",
+          message: `Error in waitForSettledDom: ${e.message}
+Trace: ${e.stack}`,
+          level: 1
+        });
+      }
+    });
+  }
+  startDomDebug() {
+    return __async(this, null, function* () {
+      try {
+        yield this.page.evaluate(() => {
+          if (typeof window.debugDom === "function") {
+            window.debugDom();
+          } else {
+            this.log({
+              category: "dom",
+              message: "debugDom is not defined",
+              level: 1
+            });
+          }
+        }).catch(() => {
+        });
+      } catch (e) {
+        this.log({
+          category: "dom",
+          message: `Error in startDomDebug: ${e.message}
+Trace: ${e.stack}`,
+          level: 1
+        });
+      }
+    });
+  }
+  cleanupDomDebug() {
+    return __async(this, null, function* () {
+      if (this.debugDom) {
+        yield this.page.evaluate(() => window.cleanupDebug()).catch(() => {
+        });
+      }
+    });
+  }
+  // Recording
+  _generateId(operation) {
+    return import_crypto.default.createHash("sha256").update(operation).digest("hex");
+  }
+  _recordObservation(instruction, result) {
+    return __async(this, null, function* () {
+      const id = this._generateId(instruction);
+      this.observations[id] = { result, instruction };
+      return id;
+    });
+  }
+  _recordAction(action, result) {
+    return __async(this, null, function* () {
+      const id = this._generateId(action);
+      this.actions[id] = { result, action };
+      return id;
+    });
+  }
+  // Main methods
+  _extract(_0) {
+    return __async(this, arguments, function* ({
+      instruction,
+      schema,
+      progress = "",
+      content = {},
+      chunksSeen = [],
+      modelName
+    }) {
+      this.log({
+        category: "extraction",
+        message: `starting extraction '${instruction}'`,
+        level: 1
+      });
+      yield this._waitForSettledDom();
+      yield this.startDomDebug();
+      const { outputString, chunk, chunks } = yield this.page.evaluate(
+        (chunksSeen2) => window.processDom(chunksSeen2 != null ? chunksSeen2 : []),
+        chunksSeen
+      );
+      this.log({
+        category: "extraction",
+        message: `received output from processDom. Current chunk index: ${chunk}, Number of chunks left: ${chunks.length - chunksSeen.length}`,
+        level: 1
+      });
+      const extractionResponse = yield extract({
+        instruction,
+        progress,
+        previouslyExtractedContent: content,
+        domElements: outputString,
+        llmProvider: this.llmProvider,
+        schema,
+        modelName: modelName || this.defaultModelName,
+        chunksSeen: chunksSeen.length,
+        chunksTotal: chunks.length
+      });
+      const _a = extractionResponse, {
+        metadata: { progress: newProgress, completed }
+      } = _a, output = __objRest(_a, [
+        "metadata"
+      ]);
+      yield this.cleanupDomDebug();
+      this.log({
+        category: "extraction",
+        message: `received extraction response: ${JSON.stringify(extractionResponse)}`,
+        level: 1
+      });
+      chunksSeen.push(chunk);
+      if (completed || chunksSeen.length === chunks.length) {
+        this.log({
+          category: "extraction",
+          message: `response: ${JSON.stringify(extractionResponse)}`,
+          level: 1
+        });
+        return output;
+      } else {
+        this.log({
+          category: "extraction",
+          message: `continuing extraction, progress: '${newProgress}'`,
+          level: 1
+        });
+        yield this._waitForSettledDom();
+        return this._extract({
+          instruction,
+          schema,
+          progress: newProgress,
+          content: output,
+          chunksSeen,
+          modelName
+        });
+      }
+    });
+  }
+  _observe(_0) {
+    return __async(this, arguments, function* ({
+      instruction,
+      useVision,
+      fullPage,
+      modelName
+    }) {
+      if (!instruction) {
+        instruction = `Find elements that can be used for any future actions in the page. These may be navigation links, related pages, section/subsection links, buttons, or other interactive elements. Be comprehensive: if there are multiple elements that may be relevant for future actions, return all of them.`;
+      }
+      const model = modelName != null ? modelName : this.defaultModelName;
+      this.log({
+        category: "observation",
+        message: `starting observation: ${instruction}`,
+        level: 1
+      });
+      yield this._waitForSettledDom();
+      yield this.startDomDebug();
+      let { outputString, selectorMap } = yield this.page.evaluate(
+        (fullPage2) => fullPage2 ? window.processAllOfDom() : window.processDom([]),
+        fullPage
+      );
+      let annotatedScreenshot;
+      if (useVision === true) {
+        if (!modelsWithVision.includes(model)) {
+          this.log({
+            category: "observation",
+            message: `${model} does not support vision. Skipping vision processing.`,
+            level: 1
+          });
+        } else {
+          const screenshotService = new ScreenshotService(
+            this.page,
+            selectorMap,
+            this.verbose
+          );
+          annotatedScreenshot = yield screenshotService.getAnnotatedScreenshot(fullPage);
+          outputString = "n/a. use the image to find the elements.";
+        }
+      }
+      const observationResponse = yield observe({
+        instruction,
+        domElements: outputString,
+        llmProvider: this.llmProvider,
+        modelName: modelName || this.defaultModelName,
+        image: annotatedScreenshot
+      });
+      const elementsWithSelectors = observationResponse.elements.map(
+        (element) => {
+          const _a = element, { elementId } = _a, rest = __objRest(_a, ["elementId"]);
+          return __spreadProps(__spreadValues({}, rest), {
+            selector: `xpath=${selectorMap[elementId]}`
+          });
+        }
+      );
+      yield this.cleanupDomDebug();
+      this._recordObservation(instruction, elementsWithSelectors);
+      this.log({
+        category: "observation",
+        message: `found element ${JSON.stringify(elementsWithSelectors)}`,
+        level: 1
+      });
+      yield this._recordObservation(instruction, elementsWithSelectors);
+      return elementsWithSelectors;
+    });
+  }
+  _act(_0) {
+    return __async(this, arguments, function* ({
+      action,
+      steps = "",
+      chunksSeen,
+      modelName,
+      useVision,
+      verifierUseVision,
+      retries = 0
+    }) {
+      var _a;
+      const model = modelName != null ? modelName : this.defaultModelName;
+      if (!modelsWithVision.includes(model) && (useVision !== false || verifierUseVision)) {
+        this.log({
+          category: "action",
+          message: `${model} does not support vision, but useVision was set to ${useVision}. Defaulting to false.`,
+          level: 1
+        });
+        useVision = false;
+        verifierUseVision = false;
+      }
+      this.log({
+        category: "action",
+        message: `Running / Continuing action: ${action} on page: ${this.page.url()}`,
+        level: 2
+      });
+      yield this._waitForSettledDom();
+      yield this.startDomDebug();
+      this.log({
+        category: "action",
+        message: `Processing DOM...`,
+        level: 2
+      });
+      const { outputString, selectorMap, chunk, chunks } = yield this.page.evaluate(
+        ({ chunksSeen: chunksSeen2 }) => {
+          return window.processDom(chunksSeen2);
+        },
+        { chunksSeen }
+      );
+      this.log({
+        category: "action",
+        message: `Looking at chunk ${chunk}. Chunks left: ${chunks.length - chunksSeen.length}`,
+        level: 1
+      });
+      let annotatedScreenshot;
+      if (useVision === true) {
+        if (!modelsWithVision.includes(model)) {
+          this.log({
+            category: "action",
+            message: `${model} does not support vision. Skipping vision processing.`,
+            level: 1
+          });
+        } else {
+          const screenshotService = new ScreenshotService(
+            this.page,
+            selectorMap,
+            this.verbose
+          );
+          annotatedScreenshot = yield screenshotService.getAnnotatedScreenshot(false);
+        }
+      }
+      const response = yield act({
+        action,
+        domElements: outputString,
+        steps,
+        llmProvider: this.llmProvider,
+        modelName: model,
+        screenshot: annotatedScreenshot,
+        logger: this.logger
+      });
+      this.log({
+        category: "action",
+        message: `Received response from LLM: ${JSON.stringify(response)}`,
+        level: 1
+      });
+      yield this.cleanupDomDebug();
+      if (!response) {
+        if (chunksSeen.length + 1 < chunks.length) {
+          chunksSeen.push(chunk);
+          this.log({
+            category: "action",
+            message: `No action found in current chunk. Chunks seen: ${chunksSeen.length}.`,
+            level: 1
+          });
+          return this._act({
+            action,
+            steps: steps + (!steps.endsWith("\n") ? "\n" : "") + "## Step: Scrolled to another section\n",
+            chunksSeen,
+            modelName,
+            useVision,
+            verifierUseVision
+          });
+        } else if (useVision === "fallback") {
+          this.log({
+            category: "action",
+            message: `Switching to vision-based processing`,
+            level: 1
+          });
+          yield this.page.evaluate(() => window.scrollToHeight(0));
+          return yield this._act({
+            action,
+            steps,
+            chunksSeen,
+            modelName,
+            useVision: true,
+            verifierUseVision
+          });
+        } else {
+          return {
+            success: false,
+            message: `Action was not able to be completed.`,
+            action
+          };
+        }
+      }
+      const elementId = response["element"];
+      const xpath = selectorMap[elementId];
+      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";
+      this.log({
+        category: "action",
+        message: `Executing method: ${method} on element: ${elementId} (xpath: ${xpath}) with args: ${JSON.stringify(
+          args
+        )}`,
+        level: 1
+      });
+      let urlChangeString = "";
+      const locator = this.page.locator(`xpath=${xpath}`).first();
+      try {
+        const initialUrl = this.page.url();
+        if (method === "scrollIntoView") {
+          this.log({
+            category: "action",
+            message: `Scrolling element into view`,
+            level: 2
+          });
+          try {
+            yield locator.evaluate((element) => {
+              element.scrollIntoView({ behavior: "smooth", block: "center" });
+            }).catch((e) => {
+              this.log({
+                category: "action",
+                message: `Error scrolling element into view: ${e.message}
+Trace: ${e.stack}`,
+                level: 1
+              });
+            });
+          } catch (e) {
+            this.log({
+              category: "action",
+              message: `Error scrolling element into view (Retries ${retries}): ${e.message}
+Trace: ${e.stack}`,
+              level: 1
+            });
+            if (retries < 2) {
+              return this._act({
+                action,
+                steps,
+                modelName,
+                useVision,
+                verifierUseVision,
+                retries: retries + 1,
+                chunksSeen
+              });
+            }
+          }
+        } else if (method === "fill" || method === "type") {
+          try {
+            yield locator.fill("");
+            yield locator.click();
+            const text = args[0];
+            for (const char of text) {
+              yield this.page.keyboard.type(char, {
+                delay: Math.random() * 50 + 25
+              });
+            }
+          } catch (e) {
+            this.log({
+              category: "action",
+              message: `Error filling element (Retries ${retries}): ${e.message}
+Trace: ${e.stack}`,
+              level: 1
+            });
+            if (retries < 2) {
+              return this._act({
+                action,
+                steps,
+                modelName,
+                useVision,
+                verifierUseVision,
+                retries: retries + 1,
+                chunksSeen
+              });
+            }
+          }
+        } else if (method === "press") {
+          try {
+            const key = args[0];
+            yield this.page.keyboard.press(key);
+          } catch (e) {
+            this.log({
+              category: "action",
+              message: `Error pressing key (Retries ${retries}): ${e.message}
+Trace: ${e.stack}`,
+              level: 1
+            });
+            if (retries < 2) {
+              return this._act({
+                action,
+                steps,
+                modelName,
+                useVision,
+                verifierUseVision,
+                retries: retries + 1,
+                chunksSeen
+              });
+            }
+          }
+        } else if (typeof locator[method] === "function") {
+          this.log({
+            category: "action",
+            message: `Page URL before action: ${this.page.url()}`,
+            level: 2
+          });
+          try {
+            yield locator[method](...args);
+          } catch (e) {
+            this.log({
+              category: "action",
+              message: `Error performing method ${method} with args ${JSON.stringify(
+                args
+              )} (Retries: ${retries}): ${e.message}
+Trace: ${e.stack}`,
+              level: 1
+            });
+            if (retries < 2) {
+              return this._act({
+                action,
+                steps,
+                modelName,
+                useVision,
+                verifierUseVision,
+                retries: retries + 1,
+                chunksSeen
+              });
+            }
+          }
+          if (method === "click") {
+            this.log({
+              category: "action",
+              message: `Clicking element, checking for page navigation`,
+              level: 1
+            });
+            const newOpenedTab = yield Promise.race([
+              new Promise((resolve) => {
+                this.context.once("page", (page) => resolve(page));
+                setTimeout(() => resolve(null), 1500);
+              })
+            ]);
+            this.log({
+              category: "action",
+              message: `Clicked element, ${newOpenedTab ? "opened a new tab" : "no new tabs opened"}`,
+              level: 1
+            });
+            if (newOpenedTab) {
+              this.log({
+                category: "action",
+                message: `New page detected (new tab) with URL: ${newOpenedTab.url()}`,
+                level: 1
+              });
+              yield newOpenedTab.close();
+              yield this.page.goto(newOpenedTab.url());
+              yield this.page.waitForLoadState("domcontentloaded");
+              yield this._waitForSettledDom();
+            }
+            yield Promise.race([
+              this.page.waitForLoadState("networkidle"),
+              new Promise((resolve) => setTimeout(resolve, 5e3))
+            ]).catch((e) => {
+              this.log({
+                category: "action",
+                message: `Network idle timeout hit`,
+                level: 1
+              });
+            });
+            this.log({
+              category: "action",
+              message: `Finished waiting for (possible) page navigation`,
+              level: 1
+            });
+            if (this.page.url() !== initialUrl) {
+              this.log({
+                category: "action",
+                message: `New page detected with URL: ${this.page.url()}`,
+                level: 1
+              });
+            }
+          }
+        } else {
+          this.log({
+            category: "action",
+            message: `Chosen method ${method} is invalid`,
+            level: 1
+          });
+          if (retries < 2) {
+            return this._act({
+              action,
+              steps,
+              modelName: model,
+              useVision,
+              verifierUseVision,
+              retries: retries + 1,
+              chunksSeen
+            });
+          } else {
+            return {
+              success: false,
+              message: `Internal error: Chosen method ${method} is invalid`,
+              action
+            };
+          }
+        }
+        let newSteps = steps + (!steps.endsWith("\n") ? "\n" : "") + `## Step: ${response.step}
+  Element: ${elementText}
+  Action: ${response.method}
+  Reasoning: ${response.why}
+`;
+        if (urlChangeString) {
+          newSteps += `  Result (Important): ${urlChangeString}
+
+`;
+        }
+        let actionComplete = false;
+        if (response.completed) {
+          this.log({
+            category: "action",
+            message: `Action marked as completed, Verifying if this is true...`,
+            level: 1
+          });
+          let domElements = void 0;
+          let fullpageScreenshot = void 0;
+          if (verifierUseVision) {
+            try {
+              const screenshotService = new ScreenshotService(
+                this.page,
+                selectorMap,
+                this.verbose
+              );
+              fullpageScreenshot = yield screenshotService.getScreenshot(
+                true,
+                15
+              );
+            } catch (e) {
+              this.log({
+                category: "action",
+                message: `Error getting full page screenshot: ${e.message}
+. Trying again...`,
+                level: 1
+              });
+              const screenshotService = new ScreenshotService(
+                this.page,
+                selectorMap,
+                this.verbose
+              );
+              fullpageScreenshot = yield screenshotService.getScreenshot(
+                true,
+                15
+              );
+            }
+          } else {
+            ({ outputString: domElements } = yield this.page.evaluate(() => {
+              return window.processAllOfDom();
+            }));
+          }
+          actionComplete = yield verifyActCompletion({
+            goal: action,
+            steps: newSteps,
+            llmProvider: this.llmProvider,
+            modelName: model,
+            screenshot: fullpageScreenshot,
+            domElements,
+            logger: this.logger
+          });
+          this.log({
+            category: "action",
+            message: `Action completion verification result: ${actionComplete}`,
+            level: 1
+          });
+        }
+        if (!actionComplete) {
+          this.log({
+            category: "action",
+            message: `Continuing to next action step`,
+            level: 1
+          });
+          return this._act({
+            action,
+            steps: newSteps,
+            modelName,
+            chunksSeen,
+            useVision,
+            verifierUseVision
+          });
+        } else {
+          this.log({
+            category: "action",
+            message: `Action completed successfully`,
+            level: 1
+          });
+          yield this._recordAction(action, response.step);
+          return {
+            success: true,
+            message: `Action completed successfully: ${steps}${response.step}`,
+            action
+          };
+        }
+      } catch (error) {
+        this.log({
+          category: "action",
+          message: `Error performing action (Retries: ${retries}): ${error.message}
+Trace: ${error.stack}`,
+          level: 1
+        });
+        if (retries < 2) {
+          return this._act({
+            action,
+            steps,
+            modelName,
+            useVision,
+            verifierUseVision,
+            retries: retries + 1,
+            chunksSeen
+          });
+        }
+        yield this._recordAction(action, "");
+        return {
+          success: false,
+          message: `Error performing action: ${error.message}`,
+          action
+        };
+      }
+    });
+  }
+  act(_0) {
+    return __async(this, arguments, function* ({
+      action,
+      modelName,
+      useVision = "fallback"
+    }) {
+      useVision = useVision != null ? useVision : "fallback";
+      return this._act({
+        action,
+        modelName,
+        chunksSeen: [],
+        useVision,
+        verifierUseVision: useVision !== false
+      });
+    });
+  }
+  extract(_0) {
+    return __async(this, arguments, function* ({
+      instruction,
+      schema,
+      modelName
+    }) {
+      return this._extract({
+        instruction,
+        schema,
+        modelName
+      });
+    });
+  }
+  observe(options) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      return this._observe({
+        instruction: (_a = options == null ? void 0 : options.instruction) != null ? _a : "Find actions that can be performed on this page.",
+        modelName: options == null ? void 0 : options.modelName,
+        useVision: (_b = options == null ? void 0 : options.useVision) != null ? _b : false,
+        fullPage: false
+      });
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Stagehand
+});