@browserbasehq/browse-cli 0.2.0-alpha-4ff3bb831a6ef6e2d57148e7afb68ea8d23e395d → 0.2.0

package/dist/index.js

@@ -15214,7 +15214,7 @@ var init_version = __esm({
   "../core/dist/esm/lib/version.js"() {
     "use strict";
     init_cjs_shims();
-    STAGEHAND_VERSION = "3.1.0";
+    STAGEHAND_VERSION = "3.2.0";
   }
 });
 
@@ -103029,6 +103029,155 @@ function createAgentTools(v32, options) {
 
 // ../core/dist/esm/lib/v3/agent/prompts/agentSystemPrompt.js
 init_cjs_shims();
+
+// ../core/dist/esm/lib/v3/agent/utils/captchaSolver.js
+init_cjs_shims();
+var SOLVING_STARTED = "browserbase-solving-started";
+var SOLVING_FINISHED = "browserbase-solving-finished";
+var SOLVING_ERRORED = "browserbase-solving-errored";
+var SOLVE_TIMEOUT_MS = 9e4;
+var CAPTCHA_SOLVED_MSG = "A captcha was automatically detected and solved \u2014 no further interaction with the captcha is needed, even if it does not visually appear solved. Do not click the captcha checkbox, widget, or challenge again. Continue with your task.";
+var CAPTCHA_ERRORED_MSG = "A captcha was detected but the automatic captcha solver failed to solve it. You may need to try a different approach or navigate around the captcha.";
+var CAPTCHA_SYSTEM_PROMPT_NOTE = "Captchas on this page are automatically detected and solved by the browser environment. Do not interact with or attempt to solve any captchas yourself \u2014 they will be handled for you. Do not click the captcha checkbox, widget, or challenge again after it has been solved, even if it still looks unresolved. Continue with your task as if the captcha does not exist.";
+var CAPTCHA_CUA_SYSTEM_PROMPT_NOTE = "\n\nCaptchas on this page are automatically detected and solved by the browser environment. Do not interact with or attempt to solve any captchas yourself \u2014 they will be handled for you. Continue with your task as if the captcha does not exist.";
+var CaptchaSolver = class {
+  solving = false;
+  _solvedSinceLastConsume = false;
+  _erroredSinceLastConsume = false;
+  listener = null;
+  attachedPage = null;
+  pageProvider = null;
+  /** Shared promise that all concurrent waitIfSolving() callers await. */
+  waitPromise = null;
+  /** Resolves the shared waitPromise. */
+  resolveWait = null;
+  /** Timeout handle for the 90s deadline. */
+  waitTimer = null;
+  /**
+   * Initialise with a callback that returns the current active page.
+   * The listener is lazily (re-)attached whenever the active page changes.
+   */
+  init(pageProvider) {
+    this.pageProvider = pageProvider;
+  }
+  /** Whether a captcha solve is currently in progress. */
+  isSolving() {
+    return this.solving;
+  }
+  /**
+   * Ensure the console listener is attached to the current active page.
+   * If the active page has changed since the last call, the old listener
+   * is removed and a new one is installed.
+   */
+  async ensureAttached() {
+    if (!this.pageProvider)
+      return;
+    const page = await this.pageProvider();
+    if (page === this.attachedPage)
+      return;
+    this.detachListener();
+    this.attachedPage = page;
+    this.listener = (msg) => {
+      const text2 = msg.text();
+      if (text2 === SOLVING_STARTED) {
+        this.solving = true;
+      } else if (text2 === SOLVING_FINISHED) {
+        this.solving = false;
+        this._solvedSinceLastConsume = true;
+        this.settle();
+      } else if (text2 === SOLVING_ERRORED) {
+        this.solving = false;
+        this._erroredSinceLastConsume = true;
+        this.settle();
+      }
+    };
+    page.on("console", this.listener);
+  }
+  /**
+   * Returns a promise that resolves immediately if no captcha is being
+   * solved, or blocks until the solver finishes, errors, or the 90s
+   * timeout is reached.
+   *
+   * Also re-attaches the listener to the current active page if it has
+   * changed since the last call.
+   *
+   * All concurrent callers share the same promise, so no waiter is
+   * orphaned.
+   */
+  async waitIfSolving() {
+    await this.ensureAttached();
+    if (!this.solving)
+      return;
+    if (this.waitPromise)
+      return this.waitPromise;
+    this.waitPromise = new Promise((resolve4) => {
+      this.resolveWait = resolve4;
+      this.waitTimer = setTimeout(() => {
+        this.solving = false;
+        this._erroredSinceLastConsume = true;
+        this.settle();
+      }, SOLVE_TIMEOUT_MS);
+    });
+    return this.waitPromise;
+  }
+  /**
+   * Returns and resets the solve event flags.
+   * Call after `waitIfSolving()` to check whether a captcha was solved
+   * (or errored) since the last consume.  This captures events even if
+   * the solve completed between two `waitIfSolving()` calls.
+   */
+  consumeSolveResult() {
+    const result = {
+      solved: this._solvedSinceLastConsume,
+      errored: this._erroredSinceLastConsume
+    };
+    this._solvedSinceLastConsume = false;
+    this._erroredSinceLastConsume = false;
+    return result;
+  }
+  /**
+   * Remove the console listener and reset all state.
+   */
+  dispose() {
+    this.detachListener();
+    this.attachedPage = null;
+    this.pageProvider = null;
+    this.solving = false;
+    this._solvedSinceLastConsume = false;
+    this._erroredSinceLastConsume = false;
+    this.settle();
+  }
+  // ------------------------------------------------------------------
+  // Internal helpers
+  // ------------------------------------------------------------------
+  /** Remove the console listener from the currently attached page. */
+  detachListener() {
+    if (this.attachedPage && this.listener) {
+      this.attachedPage.off("console", this.listener);
+    }
+    this.listener = null;
+    if (this.solving) {
+      this._erroredSinceLastConsume = true;
+    }
+    this.solving = false;
+    this.settle();
+  }
+  /** Resolve the shared wait promise and clear the timeout. */
+  settle() {
+    if (this.waitTimer) {
+      clearTimeout(this.waitTimer);
+      this.waitTimer = null;
+    }
+    if (this.resolveWait) {
+      const resolve4 = this.resolveWait;
+      this.resolveWait = null;
+      this.waitPromise = null;
+      resolve4();
+    }
+  }
+};
+
+// ../core/dist/esm/lib/v3/agent/prompts/agentSystemPrompt.js
 function buildToolsSection(isHybridMode, hasSearch, excludeTools) {
   const excludeSet = new Set(excludeTools ?? []);
   const hybridTools = [
@@ -103102,7 +103251,7 @@ ${toolLines}
   </tools>`;
 }
 function buildAgentSystemPrompt(options) {
-  const { url: url2, executionInstruction, mode, systemInstructions, isBrowserbase = false, excludeTools, variables, useSearch = false } = options;
+  const { url: url2, executionInstruction, mode, systemInstructions, captchasAutoSolve = false, excludeTools, variables, useSearch = false } = options;
   const localeDate = (/* @__PURE__ */ new Date()).toLocaleDateString();
   const isoDate = (/* @__PURE__ */ new Date()).toISOString();
   const cdata = (text2) => `<![CDATA[${text2}]]>`;
@@ -103156,9 +103305,8 @@ function buildAgentSystemPrompt(options) {
       </secondary_tool>
     </step_1>
   </page_understanding_protocol>`;
-  const roadblocksSection = isBrowserbase ? `<roadblocks>
-    <note>captchas, popups, etc.</note>
-    <captcha>If you see a captcha, use the wait tool. It will automatically be solved by our internal solver.</captcha>
+  const roadblocksSection = captchasAutoSolve ? `<roadblocks>
+    <note>${CAPTCHA_SYSTEM_PROMPT_NOTE}</note>
   </roadblocks>` : "";
   const customInstructionsBlock = systemInstructions ? `<customInstructions>${cdata(systemInstructions)}</customInstructions>
   ` : "";
@@ -103541,7 +103689,8 @@ var V3AgentHandler = class {
   systemInstructions;
   mcpTools;
   mode;
-  constructor(v32, logger, llmClient, executionModel, systemInstructions, mcpTools, mode) {
+  captchaAutoSolveEnabled;
+  constructor(v32, logger, llmClient, executionModel, systemInstructions, mcpTools, mode, captchaAutoSolveEnabled) {
     this.v3 = v32;
     this.logger = logger;
     this.llmClient = llmClient;
@@ -103549,6 +103698,7 @@ var V3AgentHandler = class {
     this.systemInstructions = systemInstructions;
     this.mcpTools = mcpTools;
     this.mode = mode ?? "dom";
+    this.captchaAutoSolveEnabled = captchaAutoSolveEnabled ?? false;
   }
   async prepareAgent(instructionOrOptions) {
     try {
@@ -103560,7 +103710,7 @@ var V3AgentHandler = class {
         executionInstruction: options.instruction,
         mode: this.mode,
         systemInstructions: this.systemInstructions,
-        isBrowserbase: this.v3.isBrowserbase,
+        captchasAutoSolve: this.v3.isCaptchaAutoSolveEnabled,
         excludeTools: options.excludeTools,
         variables: options.variables,
         useSearch: options.useSearch
@@ -103609,9 +103759,42 @@ var V3AgentHandler = class {
       throw error46;
     }
   }
-  createPrepareStep(userCallback) {
+  createPrepareStep(userCallback, captchaSolver) {
     return async (options) => {
       processMessages(options.messages);
+      if (captchaSolver) {
+        if (captchaSolver.isSolving()) {
+          this.logger({
+            category: "agent",
+            message: "Captcha detected \u2014 waiting for Browserbase to solve it before continuing",
+            level: 1
+          });
+        }
+        await captchaSolver.waitIfSolving();
+        const { solved, errored } = captchaSolver.consumeSolveResult();
+        if (solved) {
+          options.messages.push({
+            role: "user",
+            content: CAPTCHA_SOLVED_MSG
+          });
+          this.logger({
+            category: "agent",
+            message: "Captcha solved \u2014 injected notification into agent message stream",
+            level: 1
+          });
+        }
+        if (errored) {
+          options.messages.push({
+            role: "user",
+            content: CAPTCHA_ERRORED_MSG
+          });
+          this.logger({
+            category: "agent",
+            message: "Captcha solver failed \u2014 injected error notification into agent message stream",
+            level: 1
+          });
+        }
+      }
       if (userCallback) {
         return userCallback(options);
       }
@@ -103678,6 +103861,7 @@ var V3AgentHandler = class {
       currentPageUrl: ""
     };
     let messages = [];
+    let captchaSolver;
     try {
       const { options: preparedOptions, maxSteps, systemPrompt, allTools, messages: preparedMessages, wrappedModel, initialPageUrl } = await this.prepareAgent(instructionOrOptions);
       if (shouldHighlightCursor && this.mode === "hybrid") {
@@ -103685,6 +103869,10 @@ var V3AgentHandler = class {
         await page.enableCursorOverlay().catch(() => {
         });
       }
+      if (this.captchaAutoSolveEnabled) {
+        captchaSolver = new CaptchaSolver();
+        captchaSolver.init(() => this.v3.context.awaitActivePage());
+      }
       messages = preparedMessages;
       state.currentPageUrl = initialPageUrl;
       const callbacks = instructionOrOptions.callbacks;
@@ -103707,7 +103895,7 @@ var V3AgentHandler = class {
         stopWhen: (result2) => this.handleStop(result2, maxSteps),
         temperature: 1,
         toolChoice: "auto",
-        prepareStep: this.createPrepareStep(callbacks?.prepareStep),
+        prepareStep: this.createPrepareStep(callbacks?.prepareStep, captchaSolver),
         onStepFinish: this.createStepHandler(state, callbacks?.onStepFinish),
         abortSignal: preparedOptions.signal,
         providerOptions: {
@@ -103739,6 +103927,8 @@ var V3AgentHandler = class {
         completed: false,
         messages
       };
+    } finally {
+      captchaSolver?.dispose();
     }
   }
   async stream(instructionOrOptions) {
@@ -103750,6 +103940,11 @@ var V3AgentHandler = class {
       await page.enableCursorOverlay().catch(() => {
       });
     }
+    let captchaSolver;
+    if (this.captchaAutoSolveEnabled) {
+      captchaSolver = new CaptchaSolver();
+      captchaSolver.init(() => this.v3.context.awaitActivePage());
+    }
     const callbacks = instructionOrOptions.callbacks;
     const state = {
       collectedReasoning: [],
@@ -103774,45 +103969,57 @@ var V3AgentHandler = class {
       });
       rejectResult(error46);
     };
-    const streamResult = this.llmClient.streamText({
-      model: wrappedModel,
-      messages: prependSystemMessage(systemPrompt, messages),
-      tools: allTools,
-      stopWhen: (result) => this.handleStop(result, maxSteps),
-      temperature: 1,
-      toolChoice: "auto",
-      prepareStep: this.createPrepareStep(callbacks?.prepareStep),
-      onStepFinish: this.createStepHandler(state, callbacks?.onStepFinish),
-      onError: (event) => {
-        if (callbacks?.onError) {
-          callbacks.onError(event);
-        }
-        handleError(event.error);
-      },
-      onChunk: callbacks?.onChunk,
-      onFinish: (event) => {
-        if (callbacks?.onFinish) {
-          callbacks.onFinish(event);
-        }
-        const allMessages = [...messages, ...event.response?.messages || []];
-        this.ensureDone(state, wrappedModel, allMessages, options.instruction, options.output, this.logger).then((doneResult) => {
-          const result = this.consolidateMetricsAndResult(startTime, state, doneResult.messages, event, maxSteps, doneResult.output);
-          resolveResult(result);
-        });
-      },
-      onAbort: (event) => {
-        if (callbacks?.onAbort) {
-          callbacks.onAbort(event);
+    let streamResult;
+    try {
+      streamResult = this.llmClient.streamText({
+        model: wrappedModel,
+        messages: prependSystemMessage(systemPrompt, messages),
+        tools: allTools,
+        stopWhen: (result) => this.handleStop(result, maxSteps),
+        temperature: 1,
+        toolChoice: "auto",
+        prepareStep: this.createPrepareStep(callbacks?.prepareStep, captchaSolver),
+        onStepFinish: this.createStepHandler(state, callbacks?.onStepFinish),
+        onError: (event) => {
+          captchaSolver?.dispose();
+          if (callbacks?.onError) {
+            callbacks.onError(event);
+          }
+          handleError(event.error);
+        },
+        onChunk: callbacks?.onChunk,
+        onFinish: (event) => {
+          captchaSolver?.dispose();
+          if (callbacks?.onFinish) {
+            callbacks.onFinish(event);
+          }
+          const allMessages = [
+            ...messages,
+            ...event.response?.messages || []
+          ];
+          this.ensureDone(state, wrappedModel, allMessages, options.instruction, options.output, this.logger).then((doneResult) => {
+            const result = this.consolidateMetricsAndResult(startTime, state, doneResult.messages, event, maxSteps, doneResult.output);
+            resolveResult(result);
+          });
+        },
+        onAbort: (event) => {
+          captchaSolver?.dispose();
+          if (callbacks?.onAbort) {
+            callbacks.onAbort(event);
+          }
+          const reason = options.signal?.reason ? String(options.signal.reason) : "Stream was aborted";
+          rejectResult(new AgentAbortError(reason));
+        },
+        abortSignal: options.signal,
+        providerOptions: {
+          google: { mediaResolution: "MEDIA_RESOLUTION_HIGH" },
+          openai: { store: false }
         }
-        const reason = options.signal?.reason ? String(options.signal.reason) : "Stream was aborted";
-        rejectResult(new AgentAbortError(reason));
-      },
-      abortSignal: options.signal,
-      providerOptions: {
-        google: { mediaResolution: "MEDIA_RESOLUTION_HIGH" },
-        openai: { store: false }
-      }
-    });
+      });
+    } catch (error46) {
+      captchaSolver?.dispose();
+      throw error46;
+    }
     const agentStreamResult = streamResult;
     agentStreamResult.result = resultPromise;
     return agentStreamResult;
@@ -107613,6 +107820,18 @@ var AgentClient = class {
     this.userProvidedInstructions = userProvidedInstructions;
     this.clientOptions = {};
   }
+  /** Optional hook called at the top of every step in the agent loop. */
+  preStepHook;
+  setPreStepHook(handler) {
+    this.preStepHook = handler;
+  }
+  /**
+   * Optional ephemeral context note that should be sent to the next model turn.
+   * Clients that do not support this can ignore it.
+   */
+  addContextNote(note) {
+    void note;
+  }
 };
 
 // ../core/dist/esm/lib/v3/agent/utils/imageCompression.js
@@ -107800,6 +108019,7 @@ var AnthropicCUAClient = class extends AgentClient {
     let totalInferenceTime = 0;
     try {
       while (!completed && currentStep < maxSteps) {
+        await this.preStepHook?.();
         logger({
           category: "agent",
           message: `Executing step ${currentStep + 1}/${maxSteps}`,
@@ -114205,7 +114425,10 @@ var openai_default = OpenAI;
 init_sdkErrors();
 init_FlowLogger();
 init_esm3();
+var CAPTCHA_PROCEED_TOOL = "captchaSolvedProceed";
 var OpenAICUAClient = class extends AgentClient {
+  pendingContextNotes = [];
+  captchaSolvedToolActive = false;
   apiKey;
   organization;
   baseURL;
@@ -114255,6 +114478,12 @@ var OpenAICUAClient = class extends AgentClient {
   setSafetyConfirmationHandler(handler) {
     this.safetyConfirmationHandler = handler;
   }
+  addContextNote(note) {
+    this.pendingContextNotes.push(note);
+    if (note.toLowerCase().includes("captcha")) {
+      this.captchaSolvedToolActive = true;
+    }
+  }
   /**
    * Execute a task with the OpenAI CUA
    * This is the main entry point for the agent
@@ -114277,6 +114506,7 @@ var OpenAICUAClient = class extends AgentClient {
     let totalInferenceTime = 0;
     try {
       while (!completed && currentStep < maxSteps) {
+        await this.preStepHook?.();
         logger({
           category: "agent",
           message: `Executing step ${currentStep + 1}/${maxSteps}`,
@@ -114291,6 +114521,16 @@ var OpenAICUAClient = class extends AgentClient {
         previousResponseId = result.responseId;
         if (!completed) {
           inputItems = result.nextInputItems;
+          const contextNotes = this.drainContextNotes();
+          if (contextNotes.length > 0) {
+            inputItems = [
+              ...inputItems,
+              ...contextNotes.map((note) => ({
+                role: "user",
+                content: note
+              }))
+            ];
+          }
         }
         if (result.message) {
           messageList.push(result.message);
@@ -114358,7 +114598,7 @@ var OpenAICUAClient = class extends AgentClient {
         if (item.type === "computer_call" && this.isComputerCallItem(item)) {
           logger({
             category: "agent",
-            message: `Found computer_call: ${item.action.type}, call_id: ${item.call_id}`,
+            message: `Found computer_call: ${item.action.type}, payload: ${JSON.stringify(item.action)}, call_id: ${item.call_id}`,
             level: 2
           });
           const action = this.convertComputerCallToAction(item);
@@ -114508,6 +114748,20 @@ var OpenAICUAClient = class extends AgentClient {
           ...customTools
         ];
       }
+      if (this.captchaSolvedToolActive) {
+        requestParams.tools = [
+          ...requestParams.tools,
+          {
+            type: "function",
+            name: CAPTCHA_PROCEED_TOOL,
+            function: {
+              name: CAPTCHA_PROCEED_TOOL,
+              description: "The captcha on this page was solved automatically. Call this tool to confirm and continue with your task instead of asking the user for permission.",
+              parameters: { type: "object", properties: {}, required: [] }
+            }
+          }
+        ];
+      }
       if (previousResponseId) {
         requestParams.previous_response_id = previousResponseId;
       }
@@ -114634,6 +114888,15 @@ var OpenAICUAClient = class extends AgentClient {
           }
         }
       } else if (item.type === "function_call" && this.isFunctionCallItem(item)) {
+        if (item.name === CAPTCHA_PROCEED_TOOL) {
+          this.captchaSolvedToolActive = false;
+          nextInputItems.push({
+            type: "function_call_output",
+            call_id: item.call_id,
+            output: "Confirmed. The captcha is solved. Continue completing the original task autonomously without asking for further confirmation."
+          });
+          continue;
+        }
         try {
           const action = this.convertFunctionCallToAction(item);
           if (action && this.actionHandler) {
@@ -114704,6 +114967,14 @@ var OpenAICUAClient = class extends AgentClient {
       // Spread all properties from the action
     };
   }
+  drainContextNotes() {
+    if (this.pendingContextNotes.length === 0) {
+      return [];
+    }
+    const notes = [...this.pendingContextNotes];
+    this.pendingContextNotes = [];
+    return notes;
+  }
   convertFunctionCallToAction(call) {
     try {
       const args = JSON.parse(call.arguments);
@@ -115061,6 +115332,7 @@ var GoogleCUAClient = class extends AgentClient {
     let totalInferenceTime = 0;
     try {
       while (!completed && currentStep < maxSteps) {
+        await this.preStepHook?.();
         logger({
           category: "agent",
           message: `Executing step ${currentStep + 1}/${maxSteps}`,
@@ -116228,6 +116500,7 @@ ${textPrompt}`;
     this.actionHistory = [];
     try {
       while (!completed && currentStep < maxSteps) {
+        await this.preStepHook?.();
         logger({
           category: "agent",
           message: `Executing step ${currentStep + 1}/${maxSteps}`,
@@ -116355,6 +116628,9 @@ var V3CuaAgentHandler = class {
   agentClient;
   options;
   highlightCursor;
+  captchaSolver = null;
+  captchaClickGuardRemaining = 0;
+  currentInstruction = "";
   constructor(v32, logger, options, tools) {
     this.v3 = v32;
     this.logger = logger;
@@ -116383,7 +116659,28 @@ var V3CuaAgentHandler = class {
     });
     this.agentClient.setActionHandler(async (action) => {
       this.ensureNotClosed();
+      if (this.captchaSolver) {
+        if (this.captchaSolver.isSolving()) {
+          this.logger({
+            category: "agent",
+            message: "Captcha detected \u2014 waiting for Browserbase to solve it before continuing",
+            level: 1
+          });
+        }
+        await this.captchaSolver.waitIfSolving();
+        this.handleCaptchaSolveResult(this.captchaSolver.consumeSolveResult());
+      }
       action.pageUrl = (await this.v3.context.awaitActivePage()).url();
+      if (await this.shouldSkipSolvedCaptchaInteraction(action)) {
+        this.captchaClickGuardRemaining = Math.max(0, this.captchaClickGuardRemaining - 1);
+        this.agentClient.addContextNote(`The captcha has already been solved automatically. Do not click the captcha checkbox, widget, or challenge again. Continue with the original task outside the captcha area. Original task: ${this.currentInstruction}`);
+        this.logger({
+          category: "agent",
+          message: "Skipped click on solved captcha widget \u2014 injected follow-up guidance",
+          level: 1
+        });
+        return;
+      }
       const defaultDelay = 500;
       const waitBetween = this.options.clientOptions?.waitBetweenActions || defaultDelay;
       try {
@@ -116439,6 +116736,7 @@ var V3CuaAgentHandler = class {
     const options = typeof optionsOrInstruction === "string" ? { instruction: optionsOrInstruction } : optionsOrInstruction;
     this.setSafetyConfirmationHandler(options.callbacks?.onSafetyConfirmation);
     this.highlightCursor = options.highlightCursor !== false;
+    this.currentInstruction = options.instruction;
     const page = await this.v3.context.awaitActivePage();
     const currentUrl = page.url();
     if (!currentUrl || currentUrl === "about:blank") {
@@ -116449,6 +116747,21 @@ var V3CuaAgentHandler = class {
       });
       await page.goto("https://www.google.com", { waitUntil: "load" });
     }
+    if (this.v3.isCaptchaAutoSolveEnabled) {
+      this.captchaSolver = new CaptchaSolver();
+      this.captchaSolver.init(() => this.v3.context.awaitActivePage());
+      this.agentClient.setPreStepHook(async () => {
+        if (this.captchaSolver?.isSolving()) {
+          this.logger({
+            category: "agent",
+            message: "Captcha detected \u2014 waiting for Browserbase to solve it before continuing",
+            level: 1
+          });
+        }
+        await this.captchaSolver?.waitIfSolving();
+        this.handleCaptchaSolveResult(this.captchaSolver?.consumeSolveResult());
+      });
+    }
     if (this.highlightCursor) {
       try {
         await this.injectCursor();
@@ -116462,7 +116775,13 @@ var V3CuaAgentHandler = class {
       }
     }
     const start = Date.now();
-    const result = await this.agent.execute({ options, logger: this.logger });
+    let result;
+    try {
+      result = await this.agent.execute({ options, logger: this.logger });
+    } finally {
+      this.captchaSolver?.dispose();
+      this.captchaSolver = null;
+    }
     const inferenceTimeMs = Date.now() - start;
     if (result.usage) {
       this.v3.updateMetrics(V3FunctionName.AGENT, result.usage.input_tokens, result.usage.output_tokens, result.usage.reasoning_tokens ?? 0, result.usage.cached_input_tokens ?? 0, inferenceTimeMs);
@@ -116797,6 +117116,78 @@ var V3CuaAgentHandler = class {
       return null;
     }
   }
+  handleCaptchaSolveResult(result) {
+    if (!result)
+      return;
+    if (result.solved) {
+      this.captchaClickGuardRemaining = 3;
+      this.agentClient.addContextNote(CAPTCHA_SOLVED_MSG);
+      this.logger({
+        category: "agent",
+        message: "Captcha solved \u2014 continuing with task",
+        level: 1
+      });
+    }
+    if (result.errored) {
+      this.captchaClickGuardRemaining = 0;
+      this.agentClient.addContextNote(CAPTCHA_ERRORED_MSG);
+      this.logger({
+        category: "agent",
+        message: "Captcha solver failed or errored",
+        level: 1
+      });
+    }
+  }
+  async shouldSkipSolvedCaptchaInteraction(action) {
+    if (this.captchaClickGuardRemaining <= 0) {
+      return false;
+    }
+    if (action.type !== "click") {
+      return false;
+    }
+    const x3 = action.x;
+    const y2 = action.y;
+    if (typeof x3 !== "number" || typeof y2 !== "number") {
+      return false;
+    }
+    try {
+      const page = await this.v3.context.awaitActivePage();
+      const boxes = await page.evaluate(() => {
+        const selectors = [
+          'iframe[title*="reCAPTCHA"]',
+          'iframe[src*="recaptcha"]',
+          'iframe[src*="hcaptcha"]',
+          'iframe[src*="turnstile"]',
+          ".g-recaptcha",
+          "[data-sitekey]",
+          '[class*="captcha"]',
+          '[id*="captcha"]'
+        ];
+        const seen = /* @__PURE__ */ new Set();
+        const bounds = [];
+        for (const selector of selectors) {
+          for (const element of document.querySelectorAll(selector)) {
+            if (seen.has(element))
+              continue;
+            seen.add(element);
+            const rect = element.getBoundingClientRect();
+            if (rect.width <= 0 || rect.height <= 0)
+              continue;
+            bounds.push({
+              left: rect.left,
+              top: rect.top,
+              right: rect.right,
+              bottom: rect.bottom
+            });
+          }
+        }
+        return bounds;
+      });
+      return boxes.some((box) => x3 >= box.left && x3 <= box.right && y2 >= box.top && y2 <= box.bottom);
+    } catch {
+      return false;
+    }
+  }
   async injectCursor() {
     try {
       const page = await this.v3.context.awaitActivePage();
@@ -162401,6 +162792,13 @@ var V3 = (() => {
     get isBrowserbase() {
       return this.state.kind === "BROWSERBASE";
     }
+    /**
+     * Returns true if captcha auto-solving is enabled on Browserbase.
+     * Defaults to true when not explicitly set to false.
+     */
+    get isCaptchaAutoSolveEnabled() {
+      return this.isBrowserbase && this.opts.browserbaseSessionCreateParams?.browserSettings?.solveCaptchas !== false;
+    }
     /**
      * Returns true if advancedStealth is enabled in Browserbase settings.
      */
@@ -163421,7 +163819,7 @@ var V3 = (() => {
       const tools = options?.integrations ? await resolveTools(options.integrations, options.tools) : options?.tools ?? {};
       const agentLlmClient = options?.model ? this.resolveLlmClient(options.model) : this.llmClient;
       const resolvedExecutionModel = options?.executionModel ?? options?.model;
-      const handler = new V3AgentHandler(this, this.logger, agentLlmClient, resolvedExecutionModel, options?.systemPrompt, tools, options?.mode);
+      const handler = new V3AgentHandler(this, this.logger, agentLlmClient, resolvedExecutionModel, options?.systemPrompt, tools, options?.mode, this.isCaptchaAutoSolveEnabled);
       const resolvedOptions = typeof instructionOrOptions === "string" ? {
         instruction: instructionOrOptions,
         toolTimeout: DEFAULT_AGENT_TOOL_TIMEOUT_MS
@@ -163510,8 +163908,8 @@ var V3 = (() => {
           const handler = new V3CuaAgentHandler(this, this.logger, {
             modelName,
             clientOptions,
-            userProvidedInstructions: options.systemPrompt ?? `You are a helpful assistant that can use a web browser.
-Do not ask follow up questions, the user will trust your judgement.`
+            userProvidedInstructions: (options.systemPrompt ?? `You are a helpful assistant that can use a web browser.
+Do not ask follow up questions, the user will trust your judgement.`) + (this.isCaptchaAutoSolveEnabled ? CAPTCHA_CUA_SYSTEM_PROMPT_NOTE : "")
           }, tools);
           const resolvedOptions = typeof instructionOrOptions === "string" ? {
             instruction: instructionOrOptions,
@@ -164115,7 +164513,7 @@ var import_child_process4 = require("child_process");
 var readline = __toESM(require("readline"));
 
 // package.json
-var version3 = "0.2.0-alpha-4ff3bb831a6ef6e2d57148e7afb68ea8d23e395d";
+var version3 = "0.2.0";
 
 // src/index.ts
 var program = new import_commander.Command();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserbasehq/browse-cli",
-  "version": "0.2.0-alpha-4ff3bb831a6ef6e2d57148e7afb68ea8d23e395d",
+  "version": "0.2.0",
   "description": "Browser automation CLI for AI agents, built on Stagehand",
   "type": "commonjs",
   "license": "MIT",
@@ -47,7 +47,7 @@
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
     "ws": "^8.18.0",
-    "@browserbasehq/stagehand": "3.2.0-alpha-4ff3bb831a6ef6e2d57148e7afb68ea8d23e395d"
+    "@browserbasehq/stagehand": "3.2.0"
   },
   "devDependencies": {
     "@types/node": "^20.11.30",