@browserbasehq/orca 3.0.1-zod4 → 3.0.2-patch

package/dist/index.js

@@ -81,6 +81,278 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
+// lib/version.ts
+var STAGEHAND_VERSION;
+var init_version = __esm({
+  "lib/version.ts"() {
+    STAGEHAND_VERSION = "3.0.2-patch";
+  }
+});
+
+// lib/v3/types/public/sdkErrors.ts
+var StagehandError, StagehandDefaultError, StagehandEnvironmentError, MissingEnvironmentVariableError, UnsupportedModelError, UnsupportedModelProviderError, UnsupportedAISDKModelProviderError, InvalidAISDKModelFormatError, StagehandNotInitializedError, BrowserbaseSessionNotFoundError, CaptchaTimeoutError, MissingLLMConfigurationError, HandlerNotInitializedError, StagehandInvalidArgumentError, StagehandElementNotFoundError, AgentScreenshotProviderError, StagehandMissingArgumentError, CreateChatCompletionResponseError, StagehandEvalError, StagehandDomProcessError, StagehandClickError, LLMResponseError, StagehandIframeError, ContentFrameNotFoundError, XPathResolutionError, ExperimentalApiConflictError, ExperimentalNotConfiguredError, CuaModelRequiredError, ZodSchemaValidationError, StagehandInitError, MCPConnectionError, StagehandShadowRootMissingError, StagehandShadowSegmentEmptyError, StagehandShadowSegmentNotFoundError, ElementNotVisibleError, ResponseBodyError, ResponseParseError, TimeoutError, PageNotFoundError, ConnectionTimeoutError;
+var init_sdkErrors = __esm({
+  "lib/v3/types/public/sdkErrors.ts"() {
+    init_version();
+    StagehandError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+      }
+    };
+    StagehandDefaultError = class extends StagehandError {
+      constructor(error) {
+        if (error instanceof Error || error instanceof StagehandError) {
+          super(
+            `
+Hey! We're sorry you ran into an error. 
+Stagehand version: ${STAGEHAND_VERSION} 
+If you need help, please open a Github issue or reach out to us on Slack: https://stagehand.dev/slack
+
+Full error:
+${error.message}`
+          );
+        }
+      }
+    };
+    StagehandEnvironmentError = class extends StagehandError {
+      constructor(currentEnvironment, requiredEnvironment, feature) {
+        super(
+          `You seem to be setting the current environment to ${currentEnvironment}.Ensure the environment is set to ${requiredEnvironment} if you want to use ${feature}.`
+        );
+      }
+    };
+    MissingEnvironmentVariableError = class extends StagehandError {
+      constructor(missingEnvironmentVariable, feature) {
+        super(
+          `${missingEnvironmentVariable} is required to use ${feature}.Please set ${missingEnvironmentVariable} in your environment.`
+        );
+      }
+    };
+    UnsupportedModelError = class extends StagehandError {
+      constructor(supportedModels, feature) {
+        super(
+          feature ? `${feature} requires one of the following models: ${supportedModels}` : `please use one of the supported models: ${supportedModels}`
+        );
+      }
+    };
+    UnsupportedModelProviderError = class extends StagehandError {
+      constructor(supportedProviders, feature) {
+        super(
+          feature ? `${feature} requires one of the following model providers: ${supportedProviders}` : `please use one of the supported model providers: ${supportedProviders}`
+        );
+      }
+    };
+    UnsupportedAISDKModelProviderError = class extends StagehandError {
+      constructor(provider, supportedProviders) {
+        super(
+          `${provider} is not currently supported for aiSDK. please use one of the supported model providers: ${supportedProviders}`
+        );
+      }
+    };
+    InvalidAISDKModelFormatError = class extends StagehandError {
+      constructor(modelName) {
+        super(
+          `${modelName} does not follow correct format for specifying aiSDK models. Please define your model as 'provider/model-name'. For example: \`model: 'openai/gpt-4o-mini'\``
+        );
+      }
+    };
+    StagehandNotInitializedError = class extends StagehandError {
+      constructor(prop) {
+        super(
+          `You seem to be calling \`${prop}\` on a page in an uninitialized \`Stagehand\` object. Ensure you are running \`await stagehand.init()\` on the Stagehand object before referencing the \`page\` object.`
+        );
+      }
+    };
+    BrowserbaseSessionNotFoundError = class extends StagehandError {
+      constructor() {
+        super("No Browserbase session ID found");
+      }
+    };
+    CaptchaTimeoutError = class extends StagehandError {
+      constructor() {
+        super("Captcha timeout");
+      }
+    };
+    MissingLLMConfigurationError = class extends StagehandError {
+      constructor() {
+        super(
+          "No LLM API key or LLM Client configured. An LLM API key or a custom LLM Client is required to use act, extract, or observe."
+        );
+      }
+    };
+    HandlerNotInitializedError = class extends StagehandError {
+      constructor(handlerType) {
+        super(`${handlerType} handler not initialized`);
+      }
+    };
+    StagehandInvalidArgumentError = class extends StagehandError {
+      constructor(message) {
+        super(`InvalidArgumentError: ${message}`);
+      }
+    };
+    StagehandElementNotFoundError = class extends StagehandError {
+      constructor(xpaths) {
+        super(`Could not find an element for the given xPath(s): ${xpaths}`);
+      }
+    };
+    AgentScreenshotProviderError = class extends StagehandError {
+      constructor(message) {
+        super(`ScreenshotProviderError: ${message}`);
+      }
+    };
+    StagehandMissingArgumentError = class extends StagehandError {
+      constructor(message) {
+        super(`MissingArgumentError: ${message}`);
+      }
+    };
+    CreateChatCompletionResponseError = class extends StagehandError {
+      constructor(message) {
+        super(`CreateChatCompletionResponseError: ${message}`);
+      }
+    };
+    StagehandEvalError = class extends StagehandError {
+      constructor(message) {
+        super(`StagehandEvalError: ${message}`);
+      }
+    };
+    StagehandDomProcessError = class extends StagehandError {
+      constructor(message) {
+        super(`Error Processing Dom: ${message}`);
+      }
+    };
+    StagehandClickError = class extends StagehandError {
+      constructor(message, selector) {
+        super(
+          `Error Clicking Element with selector: ${selector} Reason: ${message}`
+        );
+      }
+    };
+    LLMResponseError = class extends StagehandError {
+      constructor(primitive, message) {
+        super(`${primitive} LLM response error: ${message}`);
+      }
+    };
+    StagehandIframeError = class extends StagehandError {
+      constructor(frameUrl, message) {
+        super(
+          `Unable to resolve frameId for iframe with URL: ${frameUrl} Full error: ${message}`
+        );
+      }
+    };
+    ContentFrameNotFoundError = class extends StagehandError {
+      constructor(selector) {
+        super(`Unable to obtain a content frame for selector: ${selector}`);
+      }
+    };
+    XPathResolutionError = class extends StagehandError {
+      constructor(xpath) {
+        super(`XPath "${xpath}" does not resolve in the current page or frames`);
+      }
+    };
+    ExperimentalApiConflictError = class extends StagehandError {
+      constructor() {
+        super(
+          "`experimental` mode cannot be used together with the Stagehand API. To use experimental features, set experimental: true, and useApi: false in the stagehand constructor. To use the Stagehand API, set experimental: false and useApi: true in the stagehand constructor. "
+        );
+      }
+    };
+    ExperimentalNotConfiguredError = class extends StagehandError {
+      constructor(featureName) {
+        super(`Feature "${featureName}" is an experimental feature, and cannot be configured when useAPI: true. 
+    Please set experimental: true and useAPI: false in the stagehand constructor to use this feature. 
+    If you wish to use the Stagehand API, please ensure ${featureName} is not defined in your function call, 
+    and set experimental: false, useAPI: true in the Stagehand constructor. `);
+      }
+    };
+    CuaModelRequiredError = class extends StagehandError {
+      constructor(availableModels) {
+        super(
+          `To use the computer use agent (CUA), please provide a CUA model in the agent constructor or stagehand config. Try one of our supported CUA models: ${availableModels.join(", ")}`
+        );
+      }
+    };
+    ZodSchemaValidationError = class extends Error {
+      constructor(received, issues) {
+        super(`Zod schema validation failed
+
+\u2014 Received \u2014
+${JSON.stringify(received, null, 2)}
+
+\u2014 Issues \u2014
+${JSON.stringify(issues, null, 2)}`);
+        this.received = received;
+        this.issues = issues;
+        this.name = "ZodSchemaValidationError";
+      }
+    };
+    StagehandInitError = class extends StagehandError {
+      constructor(message) {
+        super(message);
+      }
+    };
+    MCPConnectionError = class extends StagehandError {
+      constructor(serverUrl, originalError) {
+        const errorMessage = originalError instanceof Error ? originalError.message : String(originalError);
+        super(
+          `Failed to connect to MCP server at "${serverUrl}". ${errorMessage}. Please verify the server URL is correct and the server is running.`
+        );
+        this.serverUrl = serverUrl;
+        this.originalError = originalError;
+      }
+    };
+    StagehandShadowRootMissingError = class extends StagehandError {
+      constructor(detail) {
+        super(
+          `No shadow root present on the resolved host` + (detail ? `: ${detail}` : "")
+        );
+      }
+    };
+    StagehandShadowSegmentEmptyError = class extends StagehandError {
+      constructor() {
+        super(`Empty selector segment after shadow-DOM hop ("//")`);
+      }
+    };
+    StagehandShadowSegmentNotFoundError = class extends StagehandError {
+      constructor(segment, hint) {
+        super(
+          `Shadow segment '${segment}' matched no element inside shadow root` + (hint ? ` ${hint}` : "")
+        );
+      }
+    };
+    ElementNotVisibleError = class extends StagehandError {
+      constructor(selector) {
+        super(`Element not visible (no box model): ${selector}`);
+      }
+    };
+    ResponseBodyError = class extends StagehandError {
+      constructor(message) {
+        super(`Failed to retrieve response body: ${message}`);
+      }
+    };
+    ResponseParseError = class extends StagehandError {
+      constructor(message) {
+        super(`Failed to parse response: ${message}`);
+      }
+    };
+    TimeoutError = class extends StagehandError {
+      constructor(operation, timeoutMs) {
+        super(`${operation} timed out after ${timeoutMs}ms`);
+      }
+    };
+    PageNotFoundError = class extends StagehandError {
+      constructor(identifier) {
+        super(`No Page found for ${identifier}`);
+      }
+    };
+    ConnectionTimeoutError = class extends StagehandError {
+      constructor(message) {
+        super(`Connection timeout: ${message}`);
+      }
+    };
+  }
+});
+
 // lib/v3/logger.ts
 function bindInstanceLogger(instanceId, logger) {
   instanceLoggers.set(instanceId, logger);
@@ -951,7 +1223,11 @@ function resolveFocusFrameAndTail(page, absoluteXPath, parentByFrame, rootId) {
         selectorForIframe,
         ctxFrameId
       );
-      if (!objectId) throw new Error("Failed to resolve iframe element by XPath");
+      if (!objectId)
+        throw new StagehandIframeError(
+          selectorForIframe,
+          "Failed to resolve iframe element by XPath"
+        );
       try {
         yield parentSess.send("DOM.enable").catch(() => {
         });
@@ -972,7 +1248,10 @@ function resolveFocusFrameAndTail(page, absoluteXPath, parentByFrame, rootId) {
           }
         }
         if (!childFrameId)
-          throw new Error("Could not map iframe to child frameId");
+          throw new StagehandIframeError(
+            selectorForIframe,
+            "Could not map iframe to child frameId"
+          );
         absPrefix = prefixXPath(absPrefix || "/", selectorForIframe);
         ctxFrameId = childFrameId;
       } finally {
@@ -1004,7 +1283,11 @@ function resolveCssFocusFrameAndTail(page, rawSelector, parentByFrame, rootId) {
         parts[i],
         ctxFrameId
       );
-      if (!objectId) throw new Error("Failed to resolve iframe via CSS hop");
+      if (!objectId)
+        throw new StagehandIframeError(
+          parts[i],
+          "Failed to resolve iframe via CSS hop"
+        );
       try {
         yield parentSess.send("DOM.enable").catch(() => {
         });
@@ -1025,7 +1308,10 @@ function resolveCssFocusFrameAndTail(page, rawSelector, parentByFrame, rootId) {
           }
         }
         if (!childFrameId)
-          throw new Error("Could not map CSS iframe hop to child frameId");
+          throw new StagehandIframeError(
+            parts[i],
+            "Could not map CSS iframe hop to child frameId"
+          );
         ctxFrameId = childFrameId;
       } finally {
         yield parentSess.send("Runtime.releaseObject", { objectId }).catch(() => {
@@ -1553,6 +1839,7 @@ var init_snapshot = __esm({
   "lib/v3/understudy/a11y/snapshot.ts"() {
     init_executionContextRegistry();
     init_logger();
+    init_sdkErrors();
     IFRAME_STEP_RE = /^iframe(?:\[\d+])?$/i;
   }
 });
@@ -1981,6 +2268,7 @@ var init_locator = __esm({
     import_buffer = require("buffer");
     init_locatorScripts_generated();
     init_selectorResolver();
+    init_sdkErrors();
     Locator = class _Locator {
       constructor(frame, selector, options, nthIndex = 0) {
         this.frame = frame;
@@ -2018,7 +2306,9 @@ var init_locator = __esm({
             if (data instanceof Uint8Array) return import_buffer.Buffer.from(data);
             if (typeof data === "string") return import_buffer.Buffer.from(data);
             if (data instanceof ArrayBuffer) return import_buffer.Buffer.from(new Uint8Array(data));
-            throw new Error("Unsupported file payload buffer type");
+            throw new StagehandInvalidArgumentError(
+              "Unsupported file payload buffer type"
+            );
           };
           try {
             try {
@@ -2032,9 +2322,11 @@ var init_locator = __esm({
               );
               const ok = Boolean(res.result.value);
               if (!ok)
-                throw new Error('Target is not an <input type="file"> element');
+                throw new StagehandInvalidArgumentError(
+                  'Target is not an <input type="file"> element'
+                );
             } catch (e) {
-              throw new Error(
+              throw new StagehandInvalidArgumentError(
                 e instanceof Error ? e.message : "Unable to verify file input element"
               );
             }
@@ -2057,7 +2349,7 @@ var init_locator = __esm({
                 filePaths.push(tmp);
                 continue;
               }
-              throw new Error(
+              throw new StagehandInvalidArgumentError(
                 "Unsupported setInputFiles item \u2013 expected path or payload"
               );
             }
@@ -2123,7 +2415,7 @@ var init_locator = __esm({
               "DOM.getBoxModel",
               { objectId }
             );
-            if (!box.model) throw new Error("Element not visible (no box model)");
+            if (!box.model) throw new ElementNotVisibleError(this.selector);
             const { cx, cy } = this.centerFromBoxContent(box.model.content);
             return { x: Math.round(cx), y: Math.round(cy) };
           } finally {
@@ -2210,7 +2502,7 @@ var init_locator = __esm({
               "DOM.getBoxModel",
               { objectId }
             );
-            if (!box.model) throw new Error("Element not visible (no box model)");
+            if (!box.model) throw new ElementNotVisibleError(this.selector);
             const { cx, cy } = this.centerFromBoxContent(box.model.content);
             yield session.send("Input.dispatchMouseEvent", {
               type: "mouseMoved",
@@ -2245,7 +2537,7 @@ var init_locator = __esm({
               "DOM.getBoxModel",
               { objectId }
             );
-            if (!box.model) throw new Error("Element not visible (no box model)");
+            if (!box.model) throw new ElementNotVisibleError(this.selector);
             const { cx, cy } = this.centerFromBoxContent(box.model.content);
             yield session.send("Input.dispatchMouseEvent", {
               type: "mouseMoved",
@@ -2412,7 +2704,9 @@ var init_locator = __esm({
             }
             if (status === "error") {
               const reason = typeof (result == null ? void 0 : result.reason) === "string" && result.reason.length > 0 ? result.reason : "Failed to fill element";
-              throw new Error(`Failed to fill element (${reason})`);
+              throw new StagehandInvalidArgumentError(
+                `Failed to fill element (${reason})`
+              );
             }
             if (!status) {
               yield this.type(value);
@@ -2639,7 +2933,9 @@ var init_locator = __esm({
       nth(index) {
         const value = Number(index);
         if (!Number.isFinite(value) || value < 0) {
-          throw new Error("locator().nth() expects a non-negative index");
+          throw new StagehandInvalidArgumentError(
+            "locator().nth() expects a non-negative index"
+          );
         }
         const nextIndex = Math.floor(value);
         if (nextIndex === this.nthIndex) {
@@ -2662,7 +2958,7 @@ var init_locator = __esm({
             this.nthIndex
           );
           if (!resolved) {
-            throw new Error(`Element not found for selector: ${this.selector}`);
+            throw new StagehandElementNotFoundError([this.selector]);
           }
           return resolved;
         });
@@ -2670,7 +2966,7 @@ var init_locator = __esm({
       /** Compute a center point from a BoxModel content quad */
       centerFromBoxContent(content) {
         if (!content || content.length < 8) {
-          throw new Error("Invalid box model content quad");
+          throw new StagehandInvalidArgumentError("Invalid box model content quad");
         }
         const xs = [content[0], content[2], content[4], content[6]];
         const ys = [content[1], content[3], content[5], content[7]];
@@ -2781,6 +3077,7 @@ var FrameLocator, LocatorDelegate;
 var init_frameLocator = __esm({
   "lib/v3/understudy/frameLocator.ts"() {
     init_executionContextRegistry();
+    init_sdkErrors();
     FrameLocator = class _FrameLocator {
       constructor(page, selector, parent, root) {
         this.page = page;
@@ -2823,9 +3120,7 @@ var init_frameLocator = __esm({
               } catch (e) {
               }
             }
-            throw new Error(
-              `frameLocator: could not resolve child frame for selector: ${this.selector}`
-            );
+            throw new ContentFrameNotFoundError(this.selector);
           } finally {
             yield parentSession2.send("Runtime.releaseObject", { objectId }).catch(() => {
             });
@@ -3019,6 +3314,7 @@ var init_deepLocator = __esm({
     init_locator();
     init_logger();
     init_frameLocator();
+    init_sdkErrors();
     IFRAME_STEP_RE2 = /^iframe(?:\[\d+])?$/i;
     DeepLocatorDelegate = class _DeepLocatorDelegate {
       constructor(page, root, selector, nthIndex = 0) {
@@ -3134,7 +3430,9 @@ var init_deepLocator = __esm({
       nth(index) {
         const value = Number(index);
         if (!Number.isFinite(value) || value < 0) {
-          throw new Error("deepLocator().nth() expects a non-negative index");
+          throw new StagehandInvalidArgumentError(
+            "deepLocator().nth() expects a non-negative index"
+          );
         }
         const nextIndex = Math.floor(value);
         if (nextIndex === this.nthIndex) return this;
@@ -4049,6 +4347,15 @@ var init_consoleMessage = __esm({
 });
 
 // lib/v3/understudy/response.ts
+function isSerializableResponse(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  if (typeof candidate.requestId !== "string") return false;
+  if (!candidate.response || typeof candidate.response !== "object") {
+    return false;
+  }
+  return true;
+}
 function createDeferred() {
   let resolve3;
   let reject;
@@ -4081,7 +4388,8 @@ function parseHeadersText(headersText) {
 var Response;
 var init_response = __esm({
   "lib/v3/understudy/response.ts"() {
-    Response = class {
+    init_sdkErrors();
+    Response = class _Response {
       /**
        * Build a response wrapper from the CDP notification associated with a
        * navigation. The constructor captures the owning page/session so follow-up
@@ -4251,7 +4559,7 @@ var init_response = __esm({
             "Network.getResponseBody",
             { requestId: this.requestId }
           ).catch((error) => {
-            throw new Error(`Failed to retrieve response body: ${String(error)}`);
+            throw new ResponseBodyError(String(error));
           });
           if (result.base64Encoded) {
             return Buffer.from(result.body, "base64");
@@ -4273,7 +4581,7 @@ var init_response = __esm({
           try {
             return JSON.parse(text);
           } catch (error) {
-            throw new Error(`Failed to parse JSON response: ${String(error)}`);
+            throw new ResponseParseError(String(error));
           }
         });
       }
@@ -4308,6 +4616,33 @@ var init_response = __esm({
           this.headersObject[lower] = segments.join(", ");
         }
       }
+      /**
+       * Internal helper for creating a Response object from a Serializable
+       * goto response from the Stagehand API
+       */
+      static fromSerializable(serialized, context) {
+        var _a;
+        const reconstructed = new _Response({
+          page: context.page,
+          session: context.session,
+          requestId: serialized.requestId,
+          frameId: serialized.frameId,
+          loaderId: serialized.loaderId,
+          response: serialized.response,
+          fromServiceWorker: (_a = serialized.fromServiceWorkerFlag) != null ? _a : false
+        });
+        if (serialized.extraInfoHeaders) {
+          reconstructed.applyExtraInfo({
+            requestId: serialized.requestId,
+            headers: serialized.extraInfoHeaders,
+            headersText: serialized.extraInfoHeadersText
+          });
+        }
+        if (serialized.finishedSettled) {
+          reconstructed.markFinished(null);
+        }
+        return reconstructed;
+      }
       /** Marks the response as finished and resolves the `finished()` promise. */
       markFinished(error) {
         if (this.finishedSettled) return;
@@ -4327,6 +4662,7 @@ var Frame;
 var init_frame = __esm({
   "lib/v3/understudy/frame.ts"() {
     init_locator();
+    init_sdkErrors();
     Frame = class _Frame {
       constructor(session, frameId, pageId) {
         this.session = session;
@@ -4433,7 +4769,9 @@ var init_frame = __esm({
             }
           );
           if (res.exceptionDetails) {
-            throw new Error((_a = res.exceptionDetails.text) != null ? _a : "Evaluation failed");
+            throw new StagehandEvalError(
+              (_a = res.exceptionDetails.text) != null ? _a : "Evaluation failed"
+            );
           }
           return res.result.value;
         });
@@ -5086,6 +5424,7 @@ var init_networkManager = __esm({
 var LifecycleWatcher;
 var init_lifecycleWatcher = __esm({
   "lib/v3/understudy/lifecycleWatcher.ts"() {
+    init_sdkErrors();
     init_network();
     LifecycleWatcher = class {
       /**
@@ -5223,7 +5562,7 @@ var init_lifecycleWatcher = __esm({
       timeRemaining(deadline) {
         const remaining = deadline - Date.now();
         if (remaining <= 0) {
-          throw new Error(`Lifecycle wait timed out after ${this.timeoutMs}ms`);
+          throw new TimeoutError("Lifecycle wait", this.timeoutMs);
         }
         return remaining;
       }
@@ -5520,11 +5859,15 @@ function normalizeScreenshotClip(clip) {
   const height = Number(clip.height);
   for (const [key, value] of Object.entries({ x, y, width, height })) {
     if (!Number.isFinite(value)) {
-      throw new Error(`screenshot: clip.${key} must be a finite number`);
+      throw new StagehandInvalidArgumentError(
+        `screenshot: clip.${key} must be a finite number`
+      );
     }
   }
   if (width <= 0 || height <= 0) {
-    throw new Error("screenshot: clip width/height must be positive");
+    throw new StagehandInvalidArgumentError(
+      "screenshot: clip width/height must be positive"
+    );
   }
   return { x, y, width, height };
 }
@@ -5813,6 +6156,7 @@ function withScreenshotTimeout(timeoutMs, task) {
 }
 var init_screenshotUtils = __esm({
   "lib/v3/understudy/screenshotUtils.ts"() {
+    init_sdkErrors();
   }
 });
 
@@ -5834,7 +6178,9 @@ var init_page = __esm({
     init_networkManager();
     init_lifecycleWatcher();
     init_navigationResponseTracker();
+    init_response();
     init_consoleMessage();
+    init_sdkErrors();
     init_screenshotUtils();
     LIFECYCLE_NAME = {
       load: "load",
@@ -6151,7 +6497,7 @@ var init_page = __esm({
       }
       on(event, listener) {
         if (event !== "console") {
-          throw new Error(`Unsupported event: ${event}`);
+          throw new StagehandInvalidArgumentError(`Unsupported event: ${event}`);
         }
         const firstListener = this.consoleListeners.size === 0;
         this.consoleListeners.add(listener);
@@ -6162,7 +6508,7 @@ var init_page = __esm({
       }
       once(event, listener) {
         if (event !== "console") {
-          throw new Error(`Unsupported event: ${event}`);
+          throw new StagehandInvalidArgumentError(`Unsupported event: ${event}`);
         }
         const wrapper = (message) => {
           this.off("console", wrapper);
@@ -6172,7 +6518,7 @@ var init_page = __esm({
       }
       off(event, listener) {
         if (event !== "console") {
-          throw new Error(`Unsupported event: ${event}`);
+          throw new StagehandInvalidArgumentError(`Unsupported event: ${event}`);
         }
         this.consoleListeners.delete(listener);
         if (this.consoleListeners.size === 0) {
@@ -6361,13 +6707,19 @@ var init_page = __esm({
           });
           try {
             if (this.apiClient) {
-              yield this.apiClient.goto(
+              const result = yield this.apiClient.goto(
                 url,
                 { waitUntil: options == null ? void 0 : options.waitUntil },
                 this.mainFrameId()
               );
               this._currentUrl = url;
-              return null;
+              if (isSerializableResponse(result)) {
+                return Response.fromSerializable(result, {
+                  page: this,
+                  session: this.mainSession
+                });
+              }
+              return result;
             }
             const response = yield this.mainSession.send(
               "Page.navigate",
@@ -6592,13 +6944,17 @@ var init_page = __esm({
           const opts = options != null ? options : {};
           const type = (_a = opts.type) != null ? _a : "png";
           if (type !== "png" && type !== "jpeg") {
-            throw new Error(`screenshot: unsupported image type "${type}"`);
+            throw new StagehandInvalidArgumentError(
+              `screenshot: unsupported image type "${type}"`
+            );
           }
           if (opts.fullPage && opts.clip) {
-            throw new Error("screenshot: clip and fullPage cannot be used together");
+            throw new StagehandInvalidArgumentError(
+              "screenshot: clip and fullPage cannot be used together"
+            );
           }
           if (type === "png" && typeof opts.quality === "number") {
-            throw new Error(
+            throw new StagehandInvalidArgumentError(
               'screenshot: quality option is only valid for type="jpeg"'
             );
           }
@@ -6735,7 +7091,7 @@ var init_page = __esm({
           );
           if (exceptionDetails) {
             const msg = exceptionDetails.text || ((_a = exceptionDetails.exception) == null ? void 0 : _a.description) || "Evaluation failed";
-            throw new Error(msg);
+            throw new StagehandEvalError(msg);
           }
           return result == null ? void 0 : result.value;
         });
@@ -7374,9 +7730,12 @@ __export(v3_exports, {
   AnnotatedScreenshotText: () => AnnotatedScreenshotText,
   BrowserbaseSessionNotFoundError: () => BrowserbaseSessionNotFoundError,
   CaptchaTimeoutError: () => CaptchaTimeoutError,
+  ConnectionTimeoutError: () => ConnectionTimeoutError,
   ConsoleMessage: () => ConsoleMessage,
   ContentFrameNotFoundError: () => ContentFrameNotFoundError,
   CreateChatCompletionResponseError: () => CreateChatCompletionResponseError,
+  CuaModelRequiredError: () => CuaModelRequiredError,
+  ElementNotVisibleError: () => ElementNotVisibleError,
   ExperimentalApiConflictError: () => ExperimentalApiConflictError,
   ExperimentalNotConfiguredError: () => ExperimentalNotConfiguredError,
   HandlerNotInitializedError: () => HandlerNotInitializedError,
@@ -7387,7 +7746,10 @@ __export(v3_exports, {
   MCPConnectionError: () => MCPConnectionError,
   MissingEnvironmentVariableError: () => MissingEnvironmentVariableError,
   MissingLLMConfigurationError: () => MissingLLMConfigurationError,
+  PageNotFoundError: () => PageNotFoundError,
   Response: () => Response,
+  ResponseBodyError: () => ResponseBodyError,
+  ResponseParseError: () => ResponseParseError,
   Stagehand: () => V3,
   StagehandAPIError: () => StagehandAPIError,
   StagehandAPIUnauthorizedError: () => StagehandAPIUnauthorizedError,
@@ -7410,6 +7772,7 @@ __export(v3_exports, {
   StagehandShadowRootMissingError: () => StagehandShadowRootMissingError,
   StagehandShadowSegmentEmptyError: () => StagehandShadowSegmentEmptyError,
   StagehandShadowSegmentNotFoundError: () => StagehandShadowSegmentNotFoundError,
+  TimeoutError: () => TimeoutError,
   UnsupportedAISDKModelProviderError: () => UnsupportedAISDKModelProviderError,
   UnsupportedModelError: () => UnsupportedModelError,
   UnsupportedModelProviderError: () => UnsupportedModelProviderError,
@@ -7442,233 +7805,10 @@ var import_os2 = __toESM(require("os"));
 var import_path5 = __toESM(require("path"));
 var import_process2 = __toESM(require("process"));
 
-// lib/version.ts
-var STAGEHAND_VERSION = "3.0.1-zod4";
-
-// lib/v3/types/public/sdkErrors.ts
-var StagehandError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = this.constructor.name;
-  }
-};
-var StagehandDefaultError = class extends StagehandError {
-  constructor(error) {
-    if (error instanceof Error || error instanceof StagehandError) {
-      super(
-        `
-Hey! We're sorry you ran into an error. 
-Stagehand version: ${STAGEHAND_VERSION} 
-If you need help, please open a Github issue or reach out to us on Slack: https://stagehand.dev/slack
-
-Full error:
-${error.message}`
-      );
-    }
-  }
-};
-var StagehandEnvironmentError = class extends StagehandError {
-  constructor(currentEnvironment, requiredEnvironment, feature) {
-    super(
-      `You seem to be setting the current environment to ${currentEnvironment}.Ensure the environment is set to ${requiredEnvironment} if you want to use ${feature}.`
-    );
-  }
-};
-var MissingEnvironmentVariableError = class extends StagehandError {
-  constructor(missingEnvironmentVariable, feature) {
-    super(
-      `${missingEnvironmentVariable} is required to use ${feature}.Please set ${missingEnvironmentVariable} in your environment.`
-    );
-  }
-};
-var UnsupportedModelError = class extends StagehandError {
-  constructor(supportedModels, feature) {
-    super(
-      feature ? `${feature} requires one of the following models: ${supportedModels}` : `please use one of the supported models: ${supportedModels}`
-    );
-  }
-};
-var UnsupportedModelProviderError = class extends StagehandError {
-  constructor(supportedProviders, feature) {
-    super(
-      feature ? `${feature} requires one of the following model providers: ${supportedProviders}` : `please use one of the supported model providers: ${supportedProviders}`
-    );
-  }
-};
-var UnsupportedAISDKModelProviderError = class extends StagehandError {
-  constructor(provider, supportedProviders) {
-    super(
-      `${provider} is not currently supported for aiSDK. please use one of the supported model providers: ${supportedProviders}`
-    );
-  }
-};
-var InvalidAISDKModelFormatError = class extends StagehandError {
-  constructor(modelName) {
-    super(
-      `${modelName} does not follow correct format for specifying aiSDK models. Please define your model as 'provider/model-name'. For example: \`model: 'openai/gpt-4o-mini'\``
-    );
-  }
-};
-var StagehandNotInitializedError = class extends StagehandError {
-  constructor(prop) {
-    super(
-      `You seem to be calling \`${prop}\` on a page in an uninitialized \`Stagehand\` object. Ensure you are running \`await stagehand.init()\` on the Stagehand object before referencing the \`page\` object.`
-    );
-  }
-};
-var BrowserbaseSessionNotFoundError = class extends StagehandError {
-  constructor() {
-    super("No Browserbase session ID found");
-  }
-};
-var CaptchaTimeoutError = class extends StagehandError {
-  constructor() {
-    super("Captcha timeout");
-  }
-};
-var MissingLLMConfigurationError = class extends StagehandError {
-  constructor() {
-    super(
-      "No LLM API key or LLM Client configured. An LLM API key or a custom LLM Client is required to use act, extract, or observe."
-    );
-  }
-};
-var HandlerNotInitializedError = class extends StagehandError {
-  constructor(handlerType) {
-    super(`${handlerType} handler not initialized`);
-  }
-};
-var StagehandInvalidArgumentError = class extends StagehandError {
-  constructor(message) {
-    super(`InvalidArgumentError: ${message}`);
-  }
-};
-var StagehandElementNotFoundError = class extends StagehandError {
-  constructor(xpaths) {
-    super(`Could not find an element for the given xPath(s): ${xpaths}`);
-  }
-};
-var AgentScreenshotProviderError = class extends StagehandError {
-  constructor(message) {
-    super(`ScreenshotProviderError: ${message}`);
-  }
-};
-var StagehandMissingArgumentError = class extends StagehandError {
-  constructor(message) {
-    super(`MissingArgumentError: ${message}`);
-  }
-};
-var CreateChatCompletionResponseError = class extends StagehandError {
-  constructor(message) {
-    super(`CreateChatCompletionResponseError: ${message}`);
-  }
-};
-var StagehandEvalError = class extends StagehandError {
-  constructor(message) {
-    super(`StagehandEvalError: ${message}`);
-  }
-};
-var StagehandDomProcessError = class extends StagehandError {
-  constructor(message) {
-    super(`Error Processing Dom: ${message}`);
-  }
-};
-var StagehandClickError = class extends StagehandError {
-  constructor(message, selector) {
-    super(
-      `Error Clicking Element with selector: ${selector} Reason: ${message}`
-    );
-  }
-};
-var LLMResponseError = class extends StagehandError {
-  constructor(primitive, message) {
-    super(`${primitive} LLM response error: ${message}`);
-  }
-};
-var StagehandIframeError = class extends StagehandError {
-  constructor(frameUrl, message) {
-    super(
-      `Unable to resolve frameId for iframe with URL: ${frameUrl} Full error: ${message}`
-    );
-  }
-};
-var ContentFrameNotFoundError = class extends StagehandError {
-  constructor(selector) {
-    super(`Unable to obtain a content frame for selector: ${selector}`);
-  }
-};
-var XPathResolutionError = class extends StagehandError {
-  constructor(xpath) {
-    super(`XPath "${xpath}" does not resolve in the current page or frames`);
-  }
-};
-var ExperimentalApiConflictError = class extends StagehandError {
-  constructor() {
-    super(
-      "`experimental` mode cannot be used together with the Stagehand API. To use experimental features, set experimental: true, and useApi: false in the stagehand constructor. To use the Stagehand API, set experimental: false and useApi: true in the stagehand constructor. "
-    );
-  }
-};
-var ExperimentalNotConfiguredError = class extends StagehandError {
-  constructor(featureName) {
-    super(`Feature "${featureName}" is an experimental feature, and cannot be configured when useAPI: true. 
-    Please set experimental: true and useAPI: false in the stagehand constructor to use this feature. 
-    If you wish to use the Stagehand API, please ensure ${featureName} is not defined in your function call, 
-    and set experimental: false, useAPI: true in the Stagehand constructor. `);
-  }
-};
-var ZodSchemaValidationError = class extends Error {
-  constructor(received, issues) {
-    super(`Zod schema validation failed
-
-\u2014 Received \u2014
-${JSON.stringify(received, null, 2)}
-
-\u2014 Issues \u2014
-${JSON.stringify(issues, null, 2)}`);
-    this.received = received;
-    this.issues = issues;
-    this.name = "ZodSchemaValidationError";
-  }
-};
-var StagehandInitError = class extends StagehandError {
-  constructor(message) {
-    super(message);
-  }
-};
-var MCPConnectionError = class extends StagehandError {
-  constructor(serverUrl, originalError) {
-    const errorMessage = originalError instanceof Error ? originalError.message : String(originalError);
-    super(
-      `Failed to connect to MCP server at "${serverUrl}". ${errorMessage}. Please verify the server URL is correct and the server is running.`
-    );
-    this.serverUrl = serverUrl;
-    this.originalError = originalError;
-  }
-};
-var StagehandShadowRootMissingError = class extends StagehandError {
-  constructor(detail) {
-    super(
-      `No shadow root present on the resolved host` + (detail ? `: ${detail}` : "")
-    );
-  }
-};
-var StagehandShadowSegmentEmptyError = class extends StagehandError {
-  constructor() {
-    super(`Empty selector segment after shadow-DOM hop ("//")`);
-  }
-};
-var StagehandShadowSegmentNotFoundError = class extends StagehandError {
-  constructor(segment, hint) {
-    super(
-      `Shadow segment '${segment}' matched no element inside shadow root` + (hint ? ` ${hint}` : "")
-    );
-  }
-};
-
 // lib/utils.ts
+init_sdkErrors();
 var import_genai = require("@google/genai");
-var import_zod = require("zod");
+var import_v3 = require("zod/v3");
 var ID_PATTERN = /^\d+-\d+$/;
 function validateZodSchema(schema, data) {
   const result = schema.safeParse(data);
@@ -7692,28 +7832,28 @@ function decorateGeminiSchema(geminiSchema, zodSchema2) {
 function toGeminiSchema(zodSchema2) {
   const zodType = getZodType(zodSchema2);
   switch (zodType) {
-    case "array": {
-      const arraySchema = zodSchema2;
-      const element = arraySchema._zod.def.element;
+    case "ZodArray": {
       return decorateGeminiSchema(
         {
           type: import_genai.Type.ARRAY,
-          items: toGeminiSchema(element != null ? element : import_zod.z.any())
+          items: toGeminiSchema(
+            zodSchema2.element
+          )
         },
         zodSchema2
       );
     }
-    case "object": {
+    case "ZodObject": {
       const properties = {};
       const required = [];
-      const objectSchema = zodSchema2;
-      const shape = objectSchema._zod.def.shape;
-      Object.entries(shape).forEach(([key, value]) => {
-        properties[key] = toGeminiSchema(value);
-        if (getZodType(value) !== "optional") {
-          required.push(key);
+      Object.entries(zodSchema2.shape).forEach(
+        ([key, value]) => {
+          properties[key] = toGeminiSchema(value);
+          if (getZodType(value) !== "ZodOptional") {
+            required.push(key);
+          }
         }
-      });
+      );
       return decorateGeminiSchema(
         {
           type: import_genai.Type.OBJECT,
@@ -7723,45 +7863,39 @@ function toGeminiSchema(zodSchema2) {
         zodSchema2
       );
     }
-    case "string":
-    case "url":
+    case "ZodString":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING
         },
         zodSchema2
       );
-    case "number":
+    case "ZodNumber":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.NUMBER
         },
         zodSchema2
       );
-    case "boolean":
+    case "ZodBoolean":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.BOOLEAN
         },
         zodSchema2
       );
-    case "enum": {
-      const enumSchema = zodSchema2;
-      const values = Object.values(enumSchema._zod.def.entries);
+    case "ZodEnum":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING,
-          enum: values
+          enum: zodSchema2._def.values
         },
         zodSchema2
       );
-    }
-    case "default":
-    case "nullable":
-    case "optional": {
-      const wrapperSchema = zodSchema2;
-      const innerType = wrapperSchema._zod.def.innerType;
-      const innerSchema = toGeminiSchema(innerType);
+    case "ZodDefault":
+    case "ZodNullable":
+    case "ZodOptional": {
+      const innerSchema = toGeminiSchema(zodSchema2._def.innerType);
       return decorateGeminiSchema(
         __spreadProps(__spreadValues({}, innerSchema), {
           nullable: true
@@ -7769,23 +7903,14 @@ function toGeminiSchema(zodSchema2) {
         zodSchema2
       );
     }
-    case "literal": {
-      const literalSchema = zodSchema2;
-      const values = literalSchema._zod.def.values;
+    case "ZodLiteral":
       return decorateGeminiSchema(
         {
           type: import_genai.Type.STRING,
-          enum: values
+          enum: [zodSchema2._def.value]
         },
         zodSchema2
       );
-    }
-    case "pipe": {
-      const pipeSchema = zodSchema2;
-      const inSchema = pipeSchema._zod.def.in;
-      return toGeminiSchema(inSchema);
-    }
-    // Standalone transforms and any unknown types fall through to default
     default:
       return decorateGeminiSchema(
         {
@@ -7797,40 +7922,21 @@ function toGeminiSchema(zodSchema2) {
   }
 }
 function getZodType(schema) {
-  var _a, _b;
-  const schemaWithDef = schema;
-  if ((_b = (_a = schemaWithDef._zod) == null ? void 0 : _a.def) == null ? void 0 : _b.type) {
-    return schemaWithDef._zod.def.type;
-  }
-  throw new Error(
-    `Unable to determine Zod schema type. Schema: ${JSON.stringify(schema)}`
-  );
+  return schema._def.typeName;
 }
 function transformSchema(schema, currentPath) {
   var _a, _b;
-  if (isKind(schema, "url")) {
-    const transformed = makeIdStringSchema(schema);
-    return [transformed, [{ segments: [] }]];
-  }
-  if (isKind(schema, "string")) {
-    const stringSchema = schema;
-    const checks = stringSchema._zod.def.checks;
-    const format = (_a = stringSchema._zod.bag) == null ? void 0 : _a.format;
-    const hasUrlCheck = ((_b = checks == null ? void 0 : checks.some((check) => {
-      var _a2, _b2;
-      return ((_b2 = (_a2 = check._zod) == null ? void 0 : _a2.def) == null ? void 0 : _b2.check) === "url";
-    })) != null ? _b : false) || format === "url";
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodString)) {
+    const hasUrlCheck = (_b = (_a = schema._def.checks) == null ? void 0 : _a.some(
+      (check) => check.kind === "url"
+    )) != null ? _b : false;
     if (hasUrlCheck) {
       return [makeIdStringSchema(schema), [{ segments: [] }]];
     }
     return [schema, []];
   }
-  if (isKind(schema, "object")) {
-    const objectSchema = schema;
-    const shape = objectSchema._zod.def.shape;
-    if (!shape) {
-      return [schema, []];
-    }
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodObject)) {
+    const shape = schema._def.shape();
     const newShape = {};
     const urlPaths = [];
     let changed = false;
@@ -7852,17 +7958,12 @@ function transformSchema(schema, currentPath) {
       }
     }
     if (changed) {
-      const newSchema = import_zod.z.object(newShape);
-      return [newSchema, urlPaths];
+      return [import_v3.z.object(newShape), urlPaths];
     }
     return [schema, urlPaths];
   }
-  if (isKind(schema, "array")) {
-    const arraySchema = schema;
-    const itemType = arraySchema._zod.def.element;
-    if (!itemType) {
-      return [schema, []];
-    }
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodArray)) {
+    const itemType = schema._def.type;
     const [transformedItem, childPaths] = transformSchema(itemType, [
       ...currentPath,
       "*"
@@ -7872,17 +7973,12 @@ function transformSchema(schema, currentPath) {
       segments: ["*", ...cp.segments]
     }));
     if (changed) {
-      const newSchema = import_zod.z.array(transformedItem);
-      return [newSchema, arrayPaths];
+      return [import_v3.z.array(transformedItem), arrayPaths];
     }
     return [schema, arrayPaths];
   }
-  if (isKind(schema, "union")) {
-    const unionSchema = schema;
-    const unionOptions = unionSchema._zod.def.options;
-    if (!unionOptions || unionOptions.length === 0) {
-      return [schema, []];
-    }
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodUnion)) {
+    const unionOptions = schema._def.options;
     const newOptions = [];
     let changed = false;
     let allPaths = [];
@@ -7899,19 +7995,15 @@ function transformSchema(schema, currentPath) {
     });
     if (changed) {
       return [
-        import_zod.z.union(newOptions),
+        import_v3.z.union(newOptions),
         allPaths
       ];
     }
     return [schema, allPaths];
   }
-  if (isKind(schema, "intersection")) {
-    const intersectionSchema = schema;
-    const leftType = intersectionSchema._zod.def.left;
-    const rightType = intersectionSchema._zod.def.right;
-    if (!leftType || !rightType) {
-      return [schema, []];
-    }
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodIntersection)) {
+    const leftType = schema._def.left;
+    const rightType = schema._def.right;
     const [left, leftPaths] = transformSchema(leftType, [
       ...currentPath,
       "intersection_left"
@@ -7923,50 +8015,33 @@ function transformSchema(schema, currentPath) {
     const changed = left !== leftType || right !== rightType;
     const allPaths = [...leftPaths, ...rightPaths];
     if (changed) {
-      return [import_zod.z.intersection(left, right), allPaths];
+      return [import_v3.z.intersection(left, right), allPaths];
     }
     return [schema, allPaths];
   }
-  if (isKind(schema, "optional")) {
-    const optionalSchema = schema;
-    const innerType = optionalSchema._zod.def.innerType;
-    if (!innerType) {
-      return [schema, []];
-    }
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodOptional)) {
+    const innerType = schema._def.innerType;
     const [inner, innerPaths] = transformSchema(innerType, currentPath);
     if (inner !== innerType) {
-      return [import_zod.z.optional(inner), innerPaths];
+      return [import_v3.z.optional(inner), innerPaths];
     }
     return [schema, innerPaths];
   }
-  if (isKind(schema, "nullable")) {
-    const nullableSchema = schema;
-    const innerType = nullableSchema._zod.def.innerType;
-    if (!innerType) {
-      return [schema, []];
-    }
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodNullable)) {
+    const innerType = schema._def.innerType;
     const [inner, innerPaths] = transformSchema(innerType, currentPath);
     if (inner !== innerType) {
-      return [import_zod.z.nullable(inner), innerPaths];
+      return [import_v3.z.nullable(inner), innerPaths];
     }
     return [schema, innerPaths];
   }
-  if (isKind(schema, "pipe")) {
-    const pipeSchema = schema;
-    const inSchema = pipeSchema._zod.def.in;
-    const outSchema = pipeSchema._zod.def.out;
-    if (!inSchema || !outSchema) {
-      return [schema, []];
-    }
-    const [newIn, inPaths] = transformSchema(inSchema, currentPath);
-    const [newOut, outPaths] = transformSchema(outSchema, currentPath);
-    const allPaths = [...inPaths, ...outPaths];
-    const changed = newIn !== inSchema || newOut !== outSchema;
-    if (changed) {
-      const result = import_zod.z.pipe(newIn, newOut);
-      return [result, allPaths];
+  if (isKind(schema, import_v3.ZodFirstPartyTypeKind.ZodEffects)) {
+    const baseSchema = schema._def.schema;
+    const [newBaseSchema, basePaths] = transformSchema(baseSchema, currentPath);
+    if (newBaseSchema !== baseSchema) {
+      return [import_v3.z.effect(newBaseSchema, schema._def.effect), basePaths];
     }
-    return [schema, allPaths];
+    return [schema, basePaths];
   }
   return [schema, []];
 }
@@ -8012,18 +8087,17 @@ function injectUrls(obj, path6, idToUrlMapping) {
   }
 }
 function isKind(s, kind) {
-  try {
-    return getZodType(s) === kind;
-  } catch (e) {
-    return false;
-  }
+  return s._def.typeName === kind;
 }
 function makeIdStringSchema(orig) {
-  var _a;
-  const userDesc = (_a = orig.description) != null ? _a : "";
+  var _a, _b, _c;
+  const userDesc = (
+    // Zod ≥3.23 exposes .description directly; fall back to _def for older minor versions
+    (_c = (_b = orig.description) != null ? _b : (_a = orig._def) == null ? void 0 : _a.description) != null ? _c : ""
+  );
   const base = `This field must be the element-ID in the form 'frameId-backendId' (e.g. "0-432").`;
   const composed = userDesc.trim().length > 0 ? `${base} that follows this user-defined description: ${userDesc}` : base;
-  return import_zod.z.string().regex(ID_PATTERN).describe(composed);
+  return import_v3.z.string().regex(ID_PATTERN).describe(composed);
 }
 var providerEnvVarMap = {
   openai: "OPENAI_API_KEY",
@@ -8069,7 +8143,7 @@ function jsonSchemaToZod(schema) {
         for (const key in schema.properties) {
           shape[key] = jsonSchemaToZod(schema.properties[key]);
         }
-        let zodObject = import_zod.z.object(shape);
+        let zodObject = import_v3.z.object(shape);
         if (schema.required && Array.isArray(schema.required)) {
           const requiredFields = schema.required.reduce(
             (acc, field) => __spreadProps(__spreadValues({}, acc), { [field]: true }),
@@ -8082,30 +8156,30 @@ function jsonSchemaToZod(schema) {
         }
         return zodObject;
       } else {
-        return import_zod.z.object({});
+        return import_v3.z.object({});
       }
     case "array":
       if (schema.items) {
-        let zodArray = import_zod.z.array(jsonSchemaToZod(schema.items));
+        let zodArray = import_v3.z.array(jsonSchemaToZod(schema.items));
         if (schema.description) {
           zodArray = zodArray.describe(schema.description);
         }
         return zodArray;
       } else {
-        return import_zod.z.array(import_zod.z.any());
+        return import_v3.z.array(import_v3.z.any());
       }
     case "string": {
       if (schema.enum) {
-        return import_zod.z.string().refine((val) => schema.enum.includes(val));
+        return import_v3.z.string().refine((val) => schema.enum.includes(val));
       }
-      let zodString = import_zod.z.string();
+      let zodString = import_v3.z.string();
       if (schema.description) {
         zodString = zodString.describe(schema.description);
       }
       return zodString;
     }
     case "number": {
-      let zodNumber = import_zod.z.number();
+      let zodNumber = import_v3.z.number();
       if (schema.minimum !== void 0) {
         zodNumber = zodNumber.min(schema.minimum);
       }
@@ -8118,14 +8192,14 @@ function jsonSchemaToZod(schema) {
       return zodNumber;
     }
     case "boolean": {
-      let zodBoolean = import_zod.z.boolean();
+      let zodBoolean = import_v3.z.boolean();
       if (schema.description) {
         zodBoolean = zodBoolean.describe(schema.description);
       }
       return zodBoolean;
     }
     default:
-      return import_zod.z.any();
+      return import_v3.z.any();
   }
 }
 
@@ -8392,6 +8466,7 @@ function safeGetPageUrl(page) {
 }
 
 // lib/v3/cache/ActCache.ts
+init_sdkErrors();
 var ActCache = class {
   constructor({
     storage,
@@ -8519,7 +8594,7 @@ var ActCache = class {
     return __async(this, null, function* () {
       const handler = this.getActHandler();
       if (!handler) {
-        throw new Error("V3 not initialized. Call init() before act().");
+        throw new StagehandNotInitializedError("act()");
       }
       const execute = () => __async(this, null, function* () {
         var _a, _b, _c;
@@ -9124,7 +9199,7 @@ var CacheStorage = class _CacheStorage {
 };
 
 // lib/inference.ts
-var import_zod2 = require("zod");
+var import_v32 = require("zod/v3");
 
 // lib/prompt.ts
 function buildUserInstructionsString(userProvidedInstructions) {
@@ -9383,11 +9458,11 @@ function extract(_0) {
     logInferenceToFile = false
   }) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
-    const metadataSchema = import_zod2.z.object({
-      progress: import_zod2.z.string().describe(
+    const metadataSchema = import_v32.z.object({
+      progress: import_v32.z.string().describe(
         "progress of what has been extracted so far, as concise as possible"
       ),
-      completed: import_zod2.z.boolean().describe(
+      completed: import_v32.z.boolean().describe(
         "true if the goal is now accomplished. Use this conservatively, only when sure that the goal has been completed."
       )
     });
@@ -9537,20 +9612,20 @@ function observe(_0) {
   }) {
     var _a, _b, _c, _d;
     const isGPT5 = llmClient.modelName.includes("gpt-5");
-    const observeSchema = import_zod2.z.object({
-      elements: import_zod2.z.array(
-        import_zod2.z.object({
-          elementId: import_zod2.z.string().describe(
+    const observeSchema = import_v32.z.object({
+      elements: import_v32.z.array(
+        import_v32.z.object({
+          elementId: import_v32.z.string().describe(
             "the ID string associated with the element. Never include surrounding square brackets. This field must follow the format of 'number-number'."
           ),
-          description: import_zod2.z.string().describe(
+          description: import_v32.z.string().describe(
             "a description of the accessible element and its purpose"
           ),
-          method: import_zod2.z.string().describe(
+          method: import_v32.z.string().describe(
             "the candidate method/action to interact with the element. Select one of the available Playwright interaction methods."
           ),
-          arguments: import_zod2.z.array(
-            import_zod2.z.string().describe(
+          arguments: import_v32.z.array(
+            import_v32.z.string().describe(
               "the arguments to pass to the method. For example, for a click, the arguments are empty, but for a fill, the arguments are the value to fill in."
             )
           )
@@ -9644,20 +9719,20 @@ function act(_0) {
   }) {
     var _a, _b;
     const isGPT5 = llmClient.modelName.includes("gpt-5");
-    const actSchema = import_zod2.z.object({
-      elementId: import_zod2.z.string().describe(
+    const actSchema = import_v32.z.object({
+      elementId: import_v32.z.string().describe(
         "the ID string associated with the element. Never include surrounding square brackets. This field must follow the format of 'number-number'."
       ),
-      description: import_zod2.z.string().describe("a description of the accessible element and its purpose"),
-      method: import_zod2.z.string().describe(
+      description: import_v32.z.string().describe("a description of the accessible element and its purpose"),
+      method: import_v32.z.string().describe(
         "the candidate method/action to interact with the element. Select one of the available Playwright interaction methods."
       ),
-      arguments: import_zod2.z.array(
-        import_zod2.z.string().describe(
+      arguments: import_v32.z.array(
+        import_v32.z.string().describe(
           "the arguments to pass to the method. For example, for a click, the arguments are empty, but for a fill, the arguments are the value to fill in."
         )
       ),
-      twoStep: import_zod2.z.boolean()
+      twoStep: import_v32.z.boolean()
     });
     const messages = [
       buildActSystemPrompt(userProvidedInstructions),
@@ -9738,12 +9813,12 @@ function act(_0) {
 init_logger();
 
 // lib/v3/types/public/methods.ts
-var import_zod3 = require("zod");
-var defaultExtractSchema = import_zod3.z.object({
-  extraction: import_zod3.z.string()
+var import_v33 = require("zod/v3");
+var defaultExtractSchema = import_v33.z.object({
+  extraction: import_v33.z.string()
 });
-var pageTextSchema = import_zod3.z.object({
-  pageText: import_zod3.z.string()
+var pageTextSchema = import_v33.z.object({
+  pageText: import_v33.z.string()
 });
 var V3FunctionName = /* @__PURE__ */ ((V3FunctionName2) => {
   V3FunctionName2["ACT"] = "ACT";
@@ -9766,12 +9841,14 @@ var SupportedPlaywrightAction = /* @__PURE__ */ ((SupportedPlaywrightAction2) =>
   SupportedPlaywrightAction2["NEXT_CHUNK"] = "nextChunk";
   SupportedPlaywrightAction2["PREV_CHUNK"] = "prevChunk";
   SupportedPlaywrightAction2["SELECT_OPTION_FROM_DROPDOWN"] = "selectOptionFromDropdown";
+  SupportedPlaywrightAction2["HOVER"] = "hover";
   return SupportedPlaywrightAction2;
 })(SupportedPlaywrightAction || {});
 
 // lib/v3/handlers/handlerUtils/actHandlerUtils.ts
 init_deepLocator();
 init_logger();
+init_sdkErrors();
 var UnderstudyCommandException = class extends Error {
   constructor(message) {
     super(message);
@@ -9876,7 +9953,8 @@ var METHOD_HANDLER_MAP = {
   nextChunk: scrollToNextChunk,
   prevChunk: scrollToPreviousChunk,
   selectOptionFromDropdown: selectOption,
-  selectOption
+  selectOption,
+  hover
 };
 function selectOption(ctx) {
   return __async(this, null, function* () {
@@ -10219,6 +10297,26 @@ function scrollByElementHeight(ctx, direction) {
     }
   });
 }
+function hover(ctx) {
+  return __async(this, null, function* () {
+    const { locator, xpath } = ctx;
+    try {
+      yield locator.hover();
+    } catch (e) {
+      v3Logger({
+        category: "action",
+        message: "error attempting to hover",
+        level: 0,
+        auxiliary: {
+          error: { value: e.message, type: "string" },
+          trace: { value: e.stack, type: "string" },
+          xpath: { value: xpath, type: "string" }
+        }
+      });
+      throw new UnderstudyCommandException(e.message);
+    }
+  });
+}
 function getFrameUrl(frame) {
   return __async(this, null, function* () {
     const url = yield frame.evaluate("location.href");
@@ -10726,7 +10824,8 @@ var ActHandler = class {
 // lib/v3/handlers/extractHandler.ts
 init_logger();
 init_snapshot();
-var import_zod4 = require("zod");
+var import_v34 = require("zod/v3");
+init_sdkErrors();
 function transformUrlStringsToNumericIds(schema) {
   const [finalSchema, urlPaths] = transformSchema(schema, []);
   return [finalSchema, urlPaths];
@@ -10759,7 +10858,7 @@ var ExtractHandler = class {
           return pageTextSchema.parse(result);
         }
         if (!instruction && schema) {
-          throw new Error(
+          throw new StagehandInvalidArgumentError(
             "extract() requires an instruction when a schema is provided."
           );
         }
@@ -10780,7 +10879,7 @@ var ExtractHandler = class {
         const baseSchema = schema != null ? schema : defaultExtractSchema;
         const isObjectSchema = !!((_c = baseSchema._def) == null ? void 0 : _c.shape);
         const WRAP_KEY = "value";
-        const objectSchema = isObjectSchema ? baseSchema : import_zod4.z.object({ [WRAP_KEY]: baseSchema });
+        const objectSchema = isObjectSchema ? baseSchema : import_v34.z.object({ [WRAP_KEY]: baseSchema });
         const [transformedSchema, urlFieldPaths] = transformUrlStringsToNumericIds(objectSchema);
         const extractionResponse = yield extract({
           instruction,
@@ -10967,11 +11066,11 @@ var ObserveHandler = class {
 
 // lib/v3/agent/tools/v3-goto.ts
 var import_ai = require("ai");
-var import_zod5 = require("zod");
+var import_v35 = require("zod/v3");
 var createGotoTool = (v3) => (0, import_ai.tool)({
   description: "Navigate to a specific URL",
-  inputSchema: import_zod5.z.object({
-    url: import_zod5.z.string().describe("The URL to navigate to")
+  inputSchema: import_v35.z.object({
+    url: import_v35.z.string().describe("The URL to navigate to")
   }),
   execute: (_0) => __async(null, [_0], function* ({ url }) {
     var _a;
@@ -10999,11 +11098,11 @@ var createGotoTool = (v3) => (0, import_ai.tool)({
 
 // lib/v3/agent/tools/v3-act.ts
 var import_ai2 = require("ai");
-var import_zod6 = require("zod");
+var import_v36 = require("zod/v3");
 var createActTool = (v3, executionModel) => (0, import_ai2.tool)({
   description: "Perform an action on the page (click, type). Provide a short, specific phrase that mentions the element type.",
-  inputSchema: import_zod6.z.object({
-    action: import_zod6.z.string().describe(
+  inputSchema: import_v36.z.object({
+    action: import_v36.z.string().describe(
       'Describe what to click or type, e.g. "click the Login button" or "type "John" into the first name input"'
     )
   }),
@@ -11044,10 +11143,10 @@ var createActTool = (v3, executionModel) => (0, import_ai2.tool)({
 
 // lib/v3/agent/tools/v3-screenshot.ts
 var import_ai3 = require("ai");
-var import_zod7 = require("zod");
+var import_v37 = require("zod/v3");
 var createScreenshotTool = (v3) => (0, import_ai3.tool)({
   description: "Takes a screenshot (PNG) of the current page. Use this to quickly verify page state.",
-  inputSchema: import_zod7.z.object({}),
+  inputSchema: import_v37.z.object({}),
   execute: () => __async(null, null, function* () {
     v3.logger({
       category: "agent",
@@ -11071,11 +11170,11 @@ var createScreenshotTool = (v3) => (0, import_ai3.tool)({
 
 // lib/v3/agent/tools/v3-wait.ts
 var import_ai4 = require("ai");
-var import_zod8 = require("zod");
+var import_v38 = require("zod/v3");
 var createWaitTool = (v3) => (0, import_ai4.tool)({
   description: "Wait for a specified time",
-  inputSchema: import_zod8.z.object({
-    timeMs: import_zod8.z.number().describe("Time in milliseconds")
+  inputSchema: import_v38.z.object({
+    timeMs: import_v38.z.number().describe("Time in milliseconds")
   }),
   execute: (_0) => __async(null, [_0], function* ({ timeMs }) {
     v3.logger({
@@ -11099,11 +11198,11 @@ var createWaitTool = (v3) => (0, import_ai4.tool)({
 
 // lib/v3/agent/tools/v3-navback.ts
 var import_ai5 = require("ai");
-var import_zod9 = require("zod");
+var import_v39 = require("zod/v3");
 var createNavBackTool = (v3) => (0, import_ai5.tool)({
   description: "Navigate back to the previous page",
-  inputSchema: import_zod9.z.object({
-    reasoningText: import_zod9.z.string().describe("Why you're going back")
+  inputSchema: import_v39.z.object({
+    reasoningText: import_v39.z.string().describe("Why you're going back")
   }),
   execute: () => __async(null, null, function* () {
     v3.logger({
@@ -11123,12 +11222,12 @@ var createNavBackTool = (v3) => (0, import_ai5.tool)({
 
 // lib/v3/agent/tools/v3-close.ts
 var import_ai6 = require("ai");
-var import_zod10 = require("zod");
+var import_v310 = require("zod/v3");
 var createCloseTool = () => (0, import_ai6.tool)({
   description: "Complete the task and close",
-  inputSchema: import_zod10.z.object({
-    reasoning: import_zod10.z.string().describe("Summary of what was accomplished"),
-    taskComplete: import_zod10.z.boolean().describe("Whether the task was completed successfully")
+  inputSchema: import_v310.z.object({
+    reasoning: import_v310.z.string().describe("Summary of what was accomplished"),
+    taskComplete: import_v310.z.boolean().describe("Whether the task was completed successfully")
   }),
   execute: (_0) => __async(null, [_0], function* ({ reasoning, taskComplete }) {
     return { success: true, reasoning, taskComplete };
@@ -11137,10 +11236,10 @@ var createCloseTool = () => (0, import_ai6.tool)({
 
 // lib/v3/agent/tools/v3-ariaTree.ts
 var import_ai7 = require("ai");
-var import_zod11 = require("zod");
+var import_v311 = require("zod/v3");
 var createAriaTreeTool = (v3) => (0, import_ai7.tool)({
   description: "gets the accessibility (ARIA) hybrid tree text for the current page. use this to understand structure and content.",
-  inputSchema: import_zod11.z.object({}),
+  inputSchema: import_v311.z.object({}),
   execute: () => __async(null, null, function* () {
     v3.logger({
       category: "agent",
@@ -11168,17 +11267,17 @@ ${result.content}` }]
 
 // lib/v3/agent/tools/v3-fillform.ts
 var import_ai8 = require("ai");
-var import_zod12 = require("zod");
+var import_v312 = require("zod/v3");
 var createFillFormTool = (v3, executionModel) => (0, import_ai8.tool)({
   description: `\u{1F4DD} FORM FILL - MULTI-FIELD INPUT TOOL
 For any form with 2+ inputs/textareas. Faster than individual typing.`,
-  inputSchema: import_zod12.z.object({
-    fields: import_zod12.z.array(
-      import_zod12.z.object({
-        action: import_zod12.z.string().describe(
+  inputSchema: import_v312.z.object({
+    fields: import_v312.z.array(
+      import_v312.z.object({
+        action: import_v312.z.string().describe(
           'Description of typing action, e.g. "type foo into the email field"'
         ),
-        value: import_zod12.z.string().describe("Text to type into the target")
+        value: import_v312.z.string().describe("Text to type into the target")
       })
     ).min(1, "Provide at least one field to fill")
   }),
@@ -11222,12 +11321,12 @@ For any form with 2+ inputs/textareas. Faster than individual typing.`,
 
 // lib/v3/agent/tools/v3-scroll.ts
 var import_ai9 = require("ai");
-var import_zod13 = require("zod");
+var import_v313 = require("zod/v3");
 var createScrollTool = (v3) => (0, import_ai9.tool)({
   description: "Scroll the page",
-  inputSchema: import_zod13.z.object({
-    pixels: import_zod13.z.number().describe("Number of pixels to scroll up or down"),
-    direction: import_zod13.z.enum(["up", "down"]).describe("Direction to scroll")
+  inputSchema: import_v313.z.object({
+    pixels: import_v313.z.number().describe("Number of pixels to scroll up or down"),
+    direction: import_v313.z.enum(["up", "down"]).describe("Direction to scroll")
   }),
   execute: (_0) => __async(null, [_0], function* ({ pixels, direction }) {
     v3.logger({
@@ -11259,19 +11358,19 @@ var createScrollTool = (v3) => (0, import_ai9.tool)({
 
 // lib/v3/agent/tools/v3-extract.ts
 var import_ai10 = require("ai");
-var import_zod14 = require("zod");
+var import_v314 = require("zod/v3");
 function evaluateZodSchema(schemaStr, logger) {
   var _a;
   try {
     const fn = new Function("z", `return ${schemaStr}`);
-    return fn(import_zod14.z);
+    return fn(import_v314.z);
   } catch (e) {
     logger == null ? void 0 : logger({
       category: "agent",
       message: `Failed to evaluate schema: ${(_a = e == null ? void 0 : e.message) != null ? _a : String(e)}`,
       level: 0
     });
-    return import_zod14.z.any();
+    return import_v314.z.any();
   }
 }
 var createExtractTool = (v3, executionModel, logger) => (0, import_ai10.tool)({
@@ -11293,9 +11392,9 @@ var createExtractTool = (v3, executionModel, logger) => (0, import_ai10.tool)({
     3. Extract arrays:
        instruction: "extract all product names and prices"
        schema: "z.object({ products: z.array(z.object({ name: z.string(), price: z.number() })) })"`,
-  inputSchema: import_zod14.z.object({
-    instruction: import_zod14.z.string(),
-    schema: import_zod14.z.string().optional().describe("Zod schema as code, e.g. z.object({ title: z.string() })")
+  inputSchema: import_v314.z.object({
+    instruction: import_v314.z.string(),
+    schema: import_v314.z.string().optional().describe("Zod schema as code, e.g. z.object({ title: z.string() })")
   }),
   execute: (_0) => __async(null, [_0], function* ({ instruction, schema }) {
     var _a;
@@ -11518,6 +11617,7 @@ function createStandardAction(toolCallName, toolResult, args, reasoning) {
 }
 
 // lib/v3/handlers/v3AgentHandler.ts
+init_sdkErrors();
 var V3AgentHandler = class {
   constructor(v3, logger, llmClient, executionModel, systemInstructions, mcpTools) {
     this.v3 = v3;
@@ -11549,9 +11649,7 @@ var V3AgentHandler = class {
           { role: "user", content: options.instruction }
         ];
         if (!((_a = this.llmClient) == null ? void 0 : _a.getLanguageModel)) {
-          throw new Error(
-            "V3AgentHandler requires an AISDK-backed LLM client. Ensure your model is configured like 'openai/gpt-4.1-mini'."
-          );
+          throw new MissingLLMConfigurationError();
         }
         const baseModel = this.llmClient.getLanguageModel();
         const wrappedModel = (0, import_ai11.wrapLanguageModel)({
@@ -11698,9 +11796,13 @@ STRATEGY:
 // lib/v3/handlers/v3CuaAgentHandler.ts
 init_snapshot();
 
+// lib/v3/agent/AgentProvider.ts
+init_sdkErrors();
+
 // lib/v3/agent/AnthropicCUAClient.ts
+init_sdkErrors();
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
-var import_zod15 = require("zod");
+var import_zod_to_json_schema = require("zod-to-json-schema");
 
 // lib/v3/agent/AgentClient.ts
 var AgentClient = class {
@@ -12203,7 +12305,7 @@ var AnthropicCUAClient = class extends AgentClient {
         };
         if (this.tools && Object.keys(this.tools).length > 0) {
           const customTools = Object.entries(this.tools).map(([name, tool12]) => {
-            const jsonSchema2 = import_zod15.z.toJSONSchema(tool12.inputSchema);
+            const jsonSchema2 = (0, import_zod_to_json_schema.zodToJsonSchema)(tool12.inputSchema);
             const inputSchema = {
               type: "object",
               properties: jsonSchema2.properties || {},
@@ -12591,6 +12693,7 @@ var AnthropicCUAClient = class extends AgentClient {
 
 // lib/v3/agent/OpenAICUAClient.ts
 var import_openai = __toESM(require("openai"));
+init_sdkErrors();
 var OpenAICUAClient = class extends AgentClient {
   constructor(type, modelName, userProvidedInstructions, clientOptions, tools) {
     super(type, modelName, userProvidedInstructions);
@@ -13064,10 +13167,11 @@ var OpenAICUAClient = class extends AgentClient {
 
 // lib/v3/agent/GoogleCUAClient.ts
 var import_genai3 = require("@google/genai");
+init_sdkErrors();
 
 // lib/v3/agent/utils/googleCustomToolHandler.ts
 var import_genai2 = require("@google/genai");
-var import_zod16 = require("zod");
+var import_zod_to_json_schema2 = require("zod-to-json-schema");
 function executeGoogleCustomTool(toolName, toolArgs, tools, functionCall, logger) {
   return __async(this, null, function* () {
     try {
@@ -13135,7 +13239,7 @@ function convertToolSetToFunctionDeclarations(tools) {
 }
 function convertToolToFunctionDeclaration(name, tool12) {
   try {
-    const jsonSchema2 = import_zod16.z.toJSONSchema(tool12.inputSchema);
+    const jsonSchema2 = (0, import_zod_to_json_schema2.zodToJsonSchema)(tool12.inputSchema);
     const parameters = convertJsonSchemaToGoogleParameters(jsonSchema2);
     return {
       name,
@@ -13192,9 +13296,11 @@ var GoogleCUAClient = class extends AgentClient {
     this.environment = "ENVIRONMENT_BROWSER";
     this.tools = tools;
     this.apiKey = (clientOptions == null ? void 0 : clientOptions.apiKey) || process.env.GEMINI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY || "";
-    this.client = new import_genai3.GoogleGenAI({
+    this.baseURL = clientOptions == null ? void 0 : clientOptions.baseURL;
+    const genAIOptions = __spreadValues({
       apiKey: this.apiKey
-    });
+    }, this.baseURL ? { httpOptions: { baseUrl: this.baseURL } } : {});
+    this.client = new import_genai3.GoogleGenAI(genAIOptions);
     if ((clientOptions == null ? void 0 : clientOptions.environment) && typeof clientOptions.environment === "string") {
       this.environment = clientOptions.environment;
     }
@@ -13214,9 +13320,9 @@ var GoogleCUAClient = class extends AgentClient {
         }
       ]
     };
-    this.clientOptions = {
+    this.clientOptions = __spreadValues({
       apiKey: this.apiKey
-    };
+    }, this.baseURL ? { baseURL: this.baseURL } : {});
     if (this.tools && Object.keys(this.tools).length > 0) {
       this.updateGenerateContentConfig();
     }
@@ -13380,7 +13486,7 @@ var GoogleCUAClient = class extends AgentClient {
               config: this.generateContentConfig
             });
             if (!response.candidates || response.candidates.length === 0) {
-              throw new Error("Response has no candidates!");
+              throw new LLMResponseError("agent", "Response has no candidates!");
             }
             break;
           } catch (error) {
@@ -14380,6 +14486,7 @@ var V3CuaAgentHandler = class {
 
 // lib/v3/launch/browserbase.ts
 var import_sdk2 = __toESM(require("@browserbasehq/sdk"));
+init_sdkErrors();
 function createBrowserbaseSession(apiKey, projectId, params, resumeSessionId) {
   return __async(this, null, function* () {
     var _b;
@@ -14389,11 +14496,11 @@ function createBrowserbaseSession(apiKey, projectId, params, resumeSessionId) {
         resumeSessionId
       );
       if (!(existing == null ? void 0 : existing.id)) {
-        throw new Error(`Browserbase session not found: ${resumeSessionId}`);
+        throw new BrowserbaseSessionNotFoundError();
       }
       const ws = existing.connectUrl;
       if (!ws) {
-        throw new Error(
+        throw new StagehandInitError(
           `Browserbase session resume missing connectUrl for ${resumeSessionId}`
         );
       }
@@ -14420,7 +14527,7 @@ function createBrowserbaseSession(apiKey, projectId, params, resumeSessionId) {
     });
     const created = yield bb.sessions.create(createPayload);
     if (!(created == null ? void 0 : created.connectUrl) || !(created == null ? void 0 : created.id)) {
-      throw new Error(
+      throw new StagehandInitError(
         "Browserbase session creation returned an unexpected shape."
       );
     }
@@ -15471,6 +15578,7 @@ var Launcher = class _Launcher {
 };
 
 // lib/v3/launch/local.ts
+init_sdkErrors();
 function launchLocalChrome(opts) {
   return __async(this, null, function* () {
     var _a, _b, _c;
@@ -15515,12 +15623,15 @@ function waitForWebSocketDebuggerUrl(port, timeoutMs) {
       }
       yield new Promise((r) => setTimeout(r, 250));
     }
-    throw new Error(
+    throw new ConnectionTimeoutError(
       `Timed out waiting for /json/version on port ${port}${lastErrMsg ? ` (last error: ${lastErrMsg})` : ""}`
     );
   });
 }
 
+// lib/v3/llm/LLMProvider.ts
+init_sdkErrors();
+
 // lib/v3/llm/aisdk.ts
 var import_ai13 = require("ai");
 
@@ -15792,7 +15903,8 @@ var AISdkClient = class extends LLMClient {
 
 // lib/v3/llm/AnthropicClient.ts
 var import_sdk3 = __toESM(require("@anthropic-ai/sdk"));
-var import_zod17 = require("zod");
+var import_zod_to_json_schema3 = require("zod-to-json-schema");
+init_sdkErrors();
 var AnthropicClient = class extends LLMClient {
   constructor({
     modelName,
@@ -15902,7 +16014,7 @@ var AnthropicClient = class extends LLMClient {
       });
       let toolDefinition;
       if (options.response_model) {
-        const jsonSchema2 = import_zod17.z.toJSONSchema(options.response_model.schema);
+        const jsonSchema2 = (0, import_zod_to_json_schema3.zodToJsonSchema)(options.response_model.schema);
         const { properties: schemaProperties, required: schemaRequired } = extractSchemaProperties(jsonSchema2);
         toolDefinition = {
           name: "print_extracted_data",
@@ -16034,7 +16146,8 @@ var extractSchemaProperties = (jsonSchema2) => {
 
 // lib/v3/llm/CerebrasClient.ts
 var import_openai2 = __toESM(require("openai"));
-var import_zod18 = require("zod");
+var import_zod_to_json_schema4 = require("zod-to-json-schema");
+init_sdkErrors();
 var CerebrasClient = class extends LLMClient {
   constructor({
     modelName,
@@ -16096,7 +16209,7 @@ var CerebrasClient = class extends LLMClient {
         }
       }));
       if (options.response_model) {
-        const jsonSchema2 = import_zod18.z.toJSONSchema(options.response_model.schema);
+        const jsonSchema2 = (0, import_zod_to_json_schema4.zodToJsonSchema)(options.response_model.schema);
         const schemaProperties = jsonSchema2.properties || {};
         const schemaRequired = jsonSchema2.required || [];
         const responseTool = {
@@ -16254,6 +16367,7 @@ var CerebrasClient = class extends LLMClient {
 
 // lib/v3/llm/GoogleClient.ts
 var import_genai4 = require("@google/genai");
+init_sdkErrors();
 var roleMap = {
   user: "user",
   assistant: "model",
@@ -16621,7 +16735,8 @@ ${firstPartText.text}`;
 
 // lib/v3/llm/GroqClient.ts
 var import_openai3 = __toESM(require("openai"));
-var import_zod19 = require("zod");
+var import_zod_to_json_schema5 = require("zod-to-json-schema");
+init_sdkErrors();
 var GroqClient = class extends LLMClient {
   constructor({
     modelName,
@@ -16683,7 +16798,7 @@ var GroqClient = class extends LLMClient {
         }
       }));
       if (options.response_model) {
-        const jsonSchema2 = import_zod19.z.toJSONSchema(options.response_model.schema);
+        const jsonSchema2 = (0, import_zod_to_json_schema5.zodToJsonSchema)(options.response_model.schema);
         const schemaProperties = jsonSchema2.properties || {};
         const schemaRequired = jsonSchema2.required || [];
         const responseTool = {
@@ -16841,8 +16956,9 @@ var GroqClient = class extends LLMClient {
 
 // lib/v3/llm/OpenAIClient.ts
 var import_openai4 = __toESM(require("openai"));
-var import_zod20 = require("openai/helpers/zod");
-var import_zod21 = require("zod");
+var import_zod = require("openai/helpers/zod");
+var import_zod_to_json_schema6 = __toESM(require("zod-to-json-schema"));
+init_sdkErrors();
 var OpenAIClient = class extends LLMClient {
   constructor({
     modelName,
@@ -16953,7 +17069,7 @@ ${JSON.stringify(
         if (this.modelName.startsWith("o1") || this.modelName.startsWith("o3")) {
           try {
             const parsedSchema = JSON.stringify(
-              import_zod21.z.toJSONSchema(options.response_model.schema)
+              (0, import_zod_to_json_schema6.default)(options.response_model.schema)
             );
             options.messages.push({
               role: "user",
@@ -16979,7 +17095,7 @@ ${parsedSchema}
             throw error;
           }
         } else {
-          responseFormat = (0, import_zod20.zodResponseFormat)(
+          responseFormat = (0, import_zod.zodResponseFormat)(
             options.response_model.schema,
             options.response_model.name
           );
@@ -17163,7 +17279,7 @@ ${parsedSchema}
   }
 };
 
-// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@4.1.12/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@3.25.67/node_modules/@ai-sdk/provider-utils/dist/index.mjs
 var import_provider = require("@ai-sdk/provider");
 var import_provider2 = require("@ai-sdk/provider");
 var import_provider3 = require("@ai-sdk/provider");
@@ -17300,14 +17416,14 @@ var EventSourceParserStream = class extends TransformStream {
   }
 };
 
-// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@4.1.12/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+provider-utils@3.0.12_zod@3.25.67/node_modules/@ai-sdk/provider-utils/dist/index.mjs
 var import_provider9 = require("@ai-sdk/provider");
 var import_provider10 = require("@ai-sdk/provider");
 var import_provider11 = require("@ai-sdk/provider");
 var z42 = __toESM(require("zod/v4"), 1);
-var import_v3 = require("zod/v3");
-var import_v32 = require("zod/v3");
-var import_v33 = require("zod/v3");
+var import_v315 = require("zod/v3");
+var import_v316 = require("zod/v3");
+var import_v317 = require("zod/v3");
 function combineHeaders(...headers) {
   return headers.reduce(
     (combinedHeaders, currentHeaders) => __spreadValues(__spreadValues({}, combinedHeaders), currentHeaders != null ? currentHeaders : {}),
@@ -18124,7 +18240,7 @@ function parseArrayDef(def, refs) {
   const res = {
     type: "array"
   };
-  if (((_a = def.type) == null ? void 0 : _a._def) && ((_c = (_b = def.type) == null ? void 0 : _b._def) == null ? void 0 : _c.typeName) !== import_v32.ZodFirstPartyTypeKind.ZodAny) {
+  if (((_a = def.type) == null ? void 0 : _a._def) && ((_c = (_b = def.type) == null ? void 0 : _b._def) == null ? void 0 : _c.typeName) !== import_v316.ZodFirstPartyTypeKind.ZodAny) {
     res.items = parseDef(def.type._def, __spreadProps(__spreadValues({}, refs), {
       currentPath: [...refs.currentPath, "items"]
     }));
@@ -18613,18 +18729,18 @@ function parseRecordDef(def, refs) {
       currentPath: [...refs.currentPath, "additionalProperties"]
     }))) != null ? _a : refs.allowedAdditionalProperties
   };
-  if (((_b = def.keyType) == null ? void 0 : _b._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
+  if (((_b = def.keyType) == null ? void 0 : _b._def.typeName) === import_v317.ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
     const _a2 = parseStringDef(def.keyType._def, refs), { type } = _a2, keyType = __objRest(_a2, ["type"]);
     return __spreadProps(__spreadValues({}, schema), {
       propertyNames: keyType
     });
-  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodEnum) {
+  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === import_v317.ZodFirstPartyTypeKind.ZodEnum) {
     return __spreadProps(__spreadValues({}, schema), {
       propertyNames: {
         enum: def.keyType._def.values
       }
     });
-  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === import_v33.ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
+  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === import_v317.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === import_v317.ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
     const _b2 = parseBrandedDef(
       def.keyType._def,
       refs
@@ -18950,73 +19066,73 @@ var parseReadonlyDef = (def, refs) => {
 };
 var selectParser = (def, typeName, refs) => {
   switch (typeName) {
-    case import_v3.ZodFirstPartyTypeKind.ZodString:
+    case import_v315.ZodFirstPartyTypeKind.ZodString:
       return parseStringDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodNumber:
+    case import_v315.ZodFirstPartyTypeKind.ZodNumber:
       return parseNumberDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodObject:
+    case import_v315.ZodFirstPartyTypeKind.ZodObject:
       return parseObjectDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodBigInt:
+    case import_v315.ZodFirstPartyTypeKind.ZodBigInt:
       return parseBigintDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodBoolean:
+    case import_v315.ZodFirstPartyTypeKind.ZodBoolean:
       return parseBooleanDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodDate:
+    case import_v315.ZodFirstPartyTypeKind.ZodDate:
       return parseDateDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodUndefined:
+    case import_v315.ZodFirstPartyTypeKind.ZodUndefined:
       return parseUndefinedDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodNull:
+    case import_v315.ZodFirstPartyTypeKind.ZodNull:
       return parseNullDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodArray:
+    case import_v315.ZodFirstPartyTypeKind.ZodArray:
       return parseArrayDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodUnion:
-    case import_v3.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case import_v315.ZodFirstPartyTypeKind.ZodUnion:
+    case import_v315.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
       return parseUnionDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodIntersection:
+    case import_v315.ZodFirstPartyTypeKind.ZodIntersection:
       return parseIntersectionDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodTuple:
+    case import_v315.ZodFirstPartyTypeKind.ZodTuple:
       return parseTupleDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodRecord:
+    case import_v315.ZodFirstPartyTypeKind.ZodRecord:
       return parseRecordDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodLiteral:
+    case import_v315.ZodFirstPartyTypeKind.ZodLiteral:
       return parseLiteralDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodEnum:
+    case import_v315.ZodFirstPartyTypeKind.ZodEnum:
       return parseEnumDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodNativeEnum:
+    case import_v315.ZodFirstPartyTypeKind.ZodNativeEnum:
       return parseNativeEnumDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodNullable:
+    case import_v315.ZodFirstPartyTypeKind.ZodNullable:
       return parseNullableDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodOptional:
+    case import_v315.ZodFirstPartyTypeKind.ZodOptional:
       return parseOptionalDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodMap:
+    case import_v315.ZodFirstPartyTypeKind.ZodMap:
       return parseMapDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodSet:
+    case import_v315.ZodFirstPartyTypeKind.ZodSet:
       return parseSetDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodLazy:
+    case import_v315.ZodFirstPartyTypeKind.ZodLazy:
       return () => def.getter()._def;
-    case import_v3.ZodFirstPartyTypeKind.ZodPromise:
+    case import_v315.ZodFirstPartyTypeKind.ZodPromise:
       return parsePromiseDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodNaN:
-    case import_v3.ZodFirstPartyTypeKind.ZodNever:
+    case import_v315.ZodFirstPartyTypeKind.ZodNaN:
+    case import_v315.ZodFirstPartyTypeKind.ZodNever:
       return parseNeverDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodEffects:
+    case import_v315.ZodFirstPartyTypeKind.ZodEffects:
       return parseEffectsDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodAny:
+    case import_v315.ZodFirstPartyTypeKind.ZodAny:
       return parseAnyDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodUnknown:
+    case import_v315.ZodFirstPartyTypeKind.ZodUnknown:
       return parseUnknownDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodDefault:
+    case import_v315.ZodFirstPartyTypeKind.ZodDefault:
       return parseDefaultDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodBranded:
+    case import_v315.ZodFirstPartyTypeKind.ZodBranded:
       return parseBrandedDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodReadonly:
+    case import_v315.ZodFirstPartyTypeKind.ZodReadonly:
       return parseReadonlyDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodCatch:
+    case import_v315.ZodFirstPartyTypeKind.ZodCatch:
       return parseCatchDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodPipeline:
+    case import_v315.ZodFirstPartyTypeKind.ZodPipeline:
       return parsePipelineDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodFunction:
-    case import_v3.ZodFirstPartyTypeKind.ZodVoid:
-    case import_v3.ZodFirstPartyTypeKind.ZodSymbol:
+    case import_v315.ZodFirstPartyTypeKind.ZodFunction:
+    case import_v315.ZodFirstPartyTypeKind.ZodVoid:
+    case import_v315.ZodFirstPartyTypeKind.ZodSymbol:
       return void 0;
     default:
       return /* @__PURE__ */ ((_) => void 0)(typeName);
@@ -19103,7 +19219,7 @@ var getRefs = (options) => {
     )
   });
 };
-var zodToJsonSchema = (schema, options) => {
+var zodToJsonSchema7 = (schema, options) => {
   var _a;
   const refs = getRefs(options);
   let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
@@ -19148,7 +19264,7 @@ var zodToJsonSchema = (schema, options) => {
   combined.$schema = "http://json-schema.org/draft-07/schema#";
   return combined;
 };
-var zod_to_json_schema_default = zodToJsonSchema;
+var zod_to_json_schema_default = zodToJsonSchema7;
 function zod3Schema(zodSchema2, options) {
   var _a;
   const useReferences = (_a = options == null ? void 0 : options.useReferences) != null ? _a : false;
@@ -19240,7 +19356,7 @@ function withoutTrailingSlash(url) {
   return url == null ? void 0 : url.replace(/\/$/, "");
 }
 
-// ../../node_modules/.pnpm/@ai-sdk+openai@2.0.53_zod@4.1.12/node_modules/@ai-sdk/openai/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+openai@2.0.53_zod@3.25.67/node_modules/@ai-sdk/openai/dist/index.mjs
 var import_provider12 = require("@ai-sdk/provider");
 var import_v4 = require("zod/v4");
 var import_provider13 = require("@ai-sdk/provider");
@@ -23630,7 +23746,7 @@ function createOpenAI(options = {}) {
 }
 var openai = createOpenAI();
 
-// ../../node_modules/.pnpm/@ai-sdk+anthropic@2.0.34_zod@4.1.12/node_modules/@ai-sdk/anthropic/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+anthropic@2.0.34_zod@3.25.67/node_modules/@ai-sdk/anthropic/dist/index.mjs
 var import_provider20 = require("@ai-sdk/provider");
 var import_provider21 = require("@ai-sdk/provider");
 var import_v421 = require("zod/v4");
@@ -26669,7 +26785,7 @@ function createAnthropic(options = {}) {
 }
 var anthropic = createAnthropic();
 
-// ../../node_modules/.pnpm/@ai-sdk+google@2.0.23_zod@4.1.12/node_modules/@ai-sdk/google/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+google@2.0.23_zod@3.25.67/node_modules/@ai-sdk/google/dist/index.mjs
 var import_provider24 = require("@ai-sdk/provider");
 var import_v437 = require("zod/v4");
 var import_v438 = require("zod/v4");
@@ -28221,7 +28337,7 @@ function createGoogleGenerativeAI(options = {}) {
 }
 var google = createGoogleGenerativeAI();
 
-// ../../node_modules/.pnpm/@ai-sdk+openai-compatible@1.0.22_zod@4.1.12/node_modules/@ai-sdk/openai-compatible/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+openai-compatible@1.0.22_zod@3.25.67/node_modules/@ai-sdk/openai-compatible/dist/index.mjs
 var import_provider27 = require("@ai-sdk/provider");
 var import_v446 = require("zod/v4");
 var import_provider28 = require("@ai-sdk/provider");
@@ -29541,7 +29657,7 @@ var openaiCompatibleImageResponseSchema = import_v453.z.object({
   data: import_v453.z.array(import_v453.z.object({ b64_json: import_v453.z.string() }))
 });
 
-// ../../node_modules/.pnpm/@ai-sdk+xai@2.0.26_zod@4.1.12/node_modules/@ai-sdk/xai/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+xai@2.0.26_zod@3.25.67/node_modules/@ai-sdk/xai/dist/index.mjs
 var import_provider32 = require("@ai-sdk/provider");
 var import_v454 = require("zod/v4");
 var import_provider33 = require("@ai-sdk/provider");
@@ -30293,7 +30409,7 @@ function createXai(options = {}) {
 }
 var xai = createXai();
 
-// ../../node_modules/.pnpm/@ai-sdk+openai@2.0.53_zod@4.1.12/node_modules/@ai-sdk/openai/dist/internal/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+openai@2.0.53_zod@3.25.67/node_modules/@ai-sdk/openai/dist/internal/index.mjs
 var import_provider35 = require("@ai-sdk/provider");
 var import_v457 = require("zod/v4");
 var import_provider36 = require("@ai-sdk/provider");
@@ -34516,7 +34632,7 @@ function mapWebSearchOutput2(action) {
   }
 }
 
-// ../../node_modules/.pnpm/@ai-sdk+azure@2.0.54_zod@4.1.12/node_modules/@ai-sdk/azure/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+azure@2.0.54_zod@3.25.67/node_modules/@ai-sdk/azure/dist/index.mjs
 var azureOpenaiTools = {
   codeInterpreter: codeInterpreter2,
   fileSearch: fileSearch2,
@@ -34621,7 +34737,7 @@ function createAzure(options = {}) {
 }
 var azure = createAzure();
 
-// ../../node_modules/.pnpm/@ai-sdk+groq@2.0.24_zod@4.1.12/node_modules/@ai-sdk/groq/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+groq@2.0.24_zod@3.25.67/node_modules/@ai-sdk/groq/dist/index.mjs
 var import_provider43 = require("@ai-sdk/provider");
 var import_provider44 = require("@ai-sdk/provider");
 var import_v477 = require("zod/v4");
@@ -35503,7 +35619,7 @@ function createGroq(options = {}) {
 }
 var groq = createGroq();
 
-// ../../node_modules/.pnpm/@ai-sdk+cerebras@1.0.25_zod@4.1.12/node_modules/@ai-sdk/cerebras/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+cerebras@1.0.25_zod@3.25.67/node_modules/@ai-sdk/cerebras/dist/index.mjs
 var import_provider47 = require("@ai-sdk/provider");
 var import_v482 = require("zod/v4");
 var VERSION8 = true ? "1.0.25" : "0.0.0-test";
@@ -35555,7 +35671,7 @@ function createCerebras(options = {}) {
 }
 var cerebras = createCerebras();
 
-// ../../node_modules/.pnpm/@ai-sdk+togetherai@1.0.23_zod@4.1.12/node_modules/@ai-sdk/togetherai/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+togetherai@1.0.23_zod@3.25.67/node_modules/@ai-sdk/togetherai/dist/index.mjs
 var import_v483 = require("zod/v4");
 var TogetherAIImageModel = class {
   constructor(modelId, config) {
@@ -35686,7 +35802,7 @@ function createTogetherAI(options = {}) {
 }
 var togetherai = createTogetherAI();
 
-// ../../node_modules/.pnpm/@ai-sdk+mistral@2.0.19_zod@4.1.12/node_modules/@ai-sdk/mistral/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+mistral@2.0.19_zod@3.25.67/node_modules/@ai-sdk/mistral/dist/index.mjs
 var import_provider48 = require("@ai-sdk/provider");
 var import_v484 = require("zod/v4");
 var import_provider49 = require("@ai-sdk/provider");
@@ -36469,7 +36585,7 @@ function createMistral(options = {}) {
 }
 var mistral = createMistral();
 
-// ../../node_modules/.pnpm/@ai-sdk+deepseek@1.0.23_zod@4.1.12/node_modules/@ai-sdk/deepseek/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+deepseek@1.0.23_zod@3.25.67/node_modules/@ai-sdk/deepseek/dist/index.mjs
 var import_provider52 = require("@ai-sdk/provider");
 var import_v488 = require("zod/v4");
 var buildDeepseekMetadata = (usage) => {
@@ -36559,7 +36675,7 @@ function createDeepSeek(options = {}) {
 }
 var deepseek = createDeepSeek();
 
-// ../../node_modules/.pnpm/@ai-sdk+perplexity@2.0.13_zod@4.1.12/node_modules/@ai-sdk/perplexity/dist/index.mjs
+// ../../node_modules/.pnpm/@ai-sdk+perplexity@2.0.13_zod@3.25.67/node_modules/@ai-sdk/perplexity/dist/index.mjs
 var import_provider53 = require("@ai-sdk/provider");
 var import_v489 = require("zod/v4");
 var import_provider54 = require("@ai-sdk/provider");
@@ -36989,7 +37105,7 @@ function createPerplexity(options = {}) {
 }
 var perplexity = createPerplexity();
 
-// ../../node_modules/.pnpm/ollama-ai-provider-v2@1.5.0_zod@4.1.12/node_modules/ollama-ai-provider-v2/dist/index.mjs
+// ../../node_modules/.pnpm/ollama-ai-provider-v2@1.5.0_zod@3.25.67/node_modules/ollama-ai-provider-v2/dist/index.mjs
 var import_provider55 = require("@ai-sdk/provider");
 var import_v490 = require("zod/v4");
 var import_v491 = require("zod/v4");
@@ -38466,6 +38582,7 @@ init_logger();
 var import_client = require("@modelcontextprotocol/sdk/client/index.js");
 var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+init_sdkErrors();
 var connectToMCPServer = (serverConfig) => __async(null, null, function* () {
   try {
     let transport;
@@ -38591,6 +38708,9 @@ var LOG_LEVEL_NAMES = {
 init_consoleMessage();
 init_response();
 
+// lib/v3/types/public/index.ts
+init_sdkErrors();
+
 // examples/external_clients/aisdk.ts
 var import_ai14 = require("ai");
 var AISdkClient2 = class extends LLMClient {
@@ -38958,6 +39078,7 @@ function installV3PiercerIntoSession(session) {
 
 // lib/v3/understudy/context.ts
 init_executionContextRegistry();
+init_sdkErrors();
 function isTopLevelPage(info) {
   const ti = info;
   return info.type === "page" && ti.subtype !== "iframe";
@@ -38993,7 +39114,6 @@ var V3Context = class _V3Context {
     return __async(this, null, function* () {
       var _a, _b, _c;
       const conn = yield CdpConnection.connect(wsUrl);
-      yield conn.enableAutoAttach();
       const ctx = new _V3Context(
         conn,
         (_a = opts == null ? void 0 : opts.env) != null ? _a : "LOCAL",
@@ -39021,11 +39141,41 @@ var V3Context = class _V3Context {
         }
         yield new Promise((r) => setTimeout(r, 25));
       }
-      throw new Error(
-        `waitForFirstTopLevelPage timed out after ${timeoutMs}ms (no top-level Page)`
+      throw new TimeoutError(
+        "waitForFirstTopLevelPage (no top-level Page)",
+        timeoutMs
       );
     });
   }
+  waitForInitialTopLevelTargets(targetIds, timeoutMs = 3e3) {
+    return __async(this, null, function* () {
+      if (!targetIds.length) return;
+      const pending = new Set(targetIds);
+      const deadline = Date.now() + timeoutMs;
+      while (pending.size && Date.now() < deadline) {
+        for (const tid of Array.from(pending)) {
+          if (this.pagesByTarget.has(tid)) {
+            pending.delete(tid);
+          }
+        }
+        if (!pending.size) return;
+        yield new Promise((r) => setTimeout(r, 25));
+      }
+      if (pending.size) {
+        v3Logger({
+          category: "ctx",
+          message: "Timed out waiting for existing top-level targets to attach",
+          level: 2,
+          auxiliary: {
+            remainingTargets: {
+              value: JSON.stringify(Array.from(pending)),
+              type: "object"
+            }
+          }
+        });
+      }
+    });
+  }
   ensurePiercer(session) {
     return __async(this, null, function* () {
       const key = this.sessionKey(session);
@@ -39115,8 +39265,7 @@ var V3Context = class _V3Context {
   getFullFrameTreeByMainFrameId(rootMainFrameId) {
     return __async(this, null, function* () {
       const owner = this.resolvePageByMainFrameId(rootMainFrameId);
-      if (!owner)
-        throw new Error(`No Page found for mainFrameId=${rootMainFrameId}`);
+      if (!owner) throw new PageNotFoundError(`mainFrameId=${rootMainFrameId}`);
       return owner.asProtocolFrameTree(rootMainFrameId);
     });
   }
@@ -39139,7 +39288,7 @@ var V3Context = class _V3Context {
         if (page) return page;
         yield new Promise((r) => setTimeout(r, 25));
       }
-      throw new Error(`newPage timeout: target not attached (${targetId})`);
+      throw new TimeoutError(`newPage: target not attached (${targetId})`, 5e3);
     });
   }
   /**
@@ -39207,6 +39356,7 @@ var V3Context = class _V3Context {
           }
         })
       );
+      yield this.conn.enableAutoAttach();
       const targets = yield this.conn.getTargets();
       for (const t of targets) {
         try {
@@ -39214,6 +39364,8 @@ var V3Context = class _V3Context {
         } catch (e) {
         }
       }
+      const topLevelTargetIds = targets.filter((t) => isTopLevelPage(t)).map((t) => t.targetId);
+      yield this.waitForInitialTopLevelTargets(topLevelTargetIds);
     });
   }
   /**
@@ -39499,7 +39651,7 @@ var V3Context = class _V3Context {
         yield new Promise((r) => setTimeout(r, 25));
       }
       if (immediate) return immediate;
-      throw new Error("awaitActivePage: no page available");
+      throw new PageNotFoundError("awaitActivePage: no page available");
     });
   }
 };
@@ -39529,7 +39681,8 @@ function resolveModel(model) {
 
 // lib/v3/api.ts
 var import_fetch_cookie = __toESM(require("fetch-cookie"));
-var import_zod22 = require("zod");
+var import_zod_to_json_schema7 = __toESM(require("zod-to-json-schema"));
+init_version();
 var StagehandAPIClient = class {
   constructor({ apiKey, projectId, logger }) {
     this.apiKey = apiKey;
@@ -39623,7 +39776,7 @@ var StagehandAPIClient = class {
       options,
       frameId
     }) {
-      const jsonSchema2 = zodSchema2 ? import_zod22.z.toJSONSchema(zodSchema2) : void 0;
+      const jsonSchema2 = zodSchema2 ? (0, import_zod_to_json_schema7.default)(zodSchema2) : void 0;
       const args = {
         schema: jsonSchema2,
         instruction,
@@ -39674,9 +39827,7 @@ var StagehandAPIClient = class {
   agentExecute(agentConfig, executeOptions, frameId) {
     return __async(this, null, function* () {
       if (agentConfig.integrations && agentConfig.integrations.length > 0) {
-        throw new StagehandAPIError(
-          "MCP integrations are not supported in API mode. Set experimental: true to use MCP integrations."
-        );
+        throw new ExperimentalNotConfiguredError("MCP integrations");
       }
       if (typeof executeOptions === "object") {
         if (executeOptions.page) {
@@ -39905,7 +40056,7 @@ function resolveModelConfiguration(model) {
   if (model && typeof model === "object") {
     const _a = model, { modelName } = _a, clientOptions = __objRest(_a, ["modelName"]);
     if (!modelName) {
-      throw new Error(
+      throw new StagehandInvalidArgumentError(
         "model.modelName is required when providing client options."
       );
     }
@@ -40405,8 +40556,9 @@ var _V3 = class _V3 {
           if (this.opts.env === "BROWSERBASE") {
             const { apiKey, projectId } = this.requireBrowserbaseCreds();
             if (!apiKey || !projectId) {
-              throw new Error(
-                "BROWSERBASE credentials missing. Provide in your v3 constructor, or set BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID in your .env"
+              throw new MissingEnvironmentVariableError(
+                "BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID",
+                "Browserbase environment"
               );
             }
             this.logger({
@@ -40485,7 +40637,7 @@ var _V3 = class _V3 {
             return;
           }
           const neverEnv = this.opts.env;
-          throw new Error(`Unsupported env: ${neverEnv}`);
+          throw new StagehandInitError(`Unsupported env: ${neverEnv}`);
         }));
       } catch (error) {
         if (this.externalLogger) {
@@ -40534,8 +40686,7 @@ var _V3 = class _V3 {
   act(input, options) {
     return __async(this, null, function* () {
       return yield withInstanceLogContext(this.instanceId, () => __async(this, null, function* () {
-        if (!this.actHandler)
-          throw new Error("V3 not initialized. Call init() before act().");
+        if (!this.actHandler) throw new StagehandNotInitializedError("act()");
         let actResult;
         if (isObserveResult(input)) {
           const v3Page = yield this.resolvePage(options == null ? void 0 : options.page);
@@ -40566,7 +40717,7 @@ var _V3 = class _V3 {
           return actResult;
         }
         if (typeof input !== "string" || !input.trim()) {
-          throw new Error(
+          throw new StagehandInvalidArgumentError(
             "act(): instruction string is required unless passing an Action"
           );
         }
@@ -40633,7 +40784,7 @@ var _V3 = class _V3 {
     return __async(this, null, function* () {
       return yield withInstanceLogContext(this.instanceId, () => __async(this, null, function* () {
         if (!this.extractHandler) {
-          throw new Error("V3 not initialized. Call init() before extract().");
+          throw new StagehandNotInitializedError("extract()");
         }
         let instruction;
         let schema;
@@ -40651,7 +40802,9 @@ var _V3 = class _V3 {
           options = a || void 0;
         }
         if (!instruction && schema) {
-          throw new Error("extract(): schema provided without instruction");
+          throw new StagehandInvalidArgumentError(
+            "extract(): schema provided without instruction"
+          );
         }
         const effectiveSchema = instruction && !schema ? defaultExtractSchema : schema;
         const page = yield this.resolvePage(options == null ? void 0 : options.page);
@@ -40683,7 +40836,7 @@ var _V3 = class _V3 {
     return __async(this, null, function* () {
       return yield withInstanceLogContext(this.instanceId, () => __async(this, null, function* () {
         if (!this.observeHandler) {
-          throw new Error("V3 not initialized. Call init() before observe().");
+          throw new StagehandNotInitializedError("observe()");
         }
         let instruction;
         let options;
@@ -40727,7 +40880,7 @@ var _V3 = class _V3 {
   /** Return the browser-level CDP WebSocket endpoint. */
   connectURL() {
     if (this.state.kind === "UNINITIALIZED") {
-      throw new Error("V3 not initialized. Call await v3.init() first.");
+      throw new StagehandNotInitializedError("connectURL()");
     }
     return this.state.ws;
   }
@@ -40792,10 +40945,9 @@ var _V3 = class _V3 {
       const missing = [];
       if (!apiKey) missing.push("BROWSERBASE_API_KEY");
       if (!projectId) missing.push("BROWSERBASE_PROJECT_ID");
-      throw new Error(
-        `BROWSERBASE credentials missing. Provide in your v3 constructor, or set ${missing.join(
-          ", "
-        )} in your .env`
+      throw new MissingEnvironmentVariableError(
+        missing.join(", "),
+        "Browserbase"
       );
     }
     this.opts.apiKey = apiKey;
@@ -40841,7 +40993,9 @@ var _V3 = class _V3 {
         });
         return frameTree.frame.id;
       }
-      throw new Error("Unsupported page object passed to V3.act()");
+      throw new StagehandInvalidArgumentError(
+        "Unsupported page object passed to V3.act()"
+      );
     });
   }
   isPlaywrightPage(p) {
@@ -40861,9 +41015,7 @@ var _V3 = class _V3 {
       }
       const ctx = this.ctx;
       if (!ctx) {
-        throw new Error(
-          "V3 context not initialized. Call init() before resolving pages."
-        );
+        throw new StagehandNotInitializedError("resolvePage()");
       }
       return yield ctx.awaitActivePage();
     });
@@ -40877,24 +41029,30 @@ var _V3 = class _V3 {
         const frameId = yield this.resolveTopFrameId(input);
         const page = this.ctx.resolvePageByMainFrameId(frameId);
         if (!page)
-          throw new Error("Failed to resolve V3 Page from Playwright page.");
+          throw new StagehandInitError(
+            "Failed to resolve V3 Page from Playwright page."
+          );
         return page;
       }
       if (this.isPatchrightPage(input)) {
         const frameId = yield this.resolveTopFrameId(input);
         const page = this.ctx.resolvePageByMainFrameId(frameId);
         if (!page)
-          throw new Error("Failed to resolve V3 Page from Playwright page.");
+          throw new StagehandInitError(
+            "Failed to resolve V3 Page from Patchright page."
+          );
         return page;
       }
       if (this.isPuppeteerPage(input)) {
         const frameId = yield this.resolveTopFrameId(input);
         const page = this.ctx.resolvePageByMainFrameId(frameId);
         if (!page)
-          throw new Error("Failed to resolve V3 Page from Puppeteer page.");
+          throw new StagehandInitError(
+            "Failed to resolve V3 Page from Puppeteer page."
+          );
         return page;
       }
-      throw new Error("Unsupported page object.");
+      throw new StagehandInvalidArgumentError("Unsupported page object.");
     });
   }
   /**
@@ -40921,8 +41079,8 @@ var _V3 = class _V3 {
     });
     if (options == null ? void 0 : options.cua) {
       if (((options == null ? void 0 : options.integrations) || (options == null ? void 0 : options.tools)) && !this.experimental) {
-        throw new Error(
-          "MCP integrations and custom tools are experimental. Enable experimental: true in V3 options."
+        throw new ExperimentalNotConfiguredError(
+          "MCP integrations and custom tools"
         );
       }
       const modelToUse = (options == null ? void 0 : options.model) || __spreadValues({
@@ -40930,9 +41088,7 @@ var _V3 = class _V3 {
       }, this.modelClientOptions);
       const { modelName, isCua, clientOptions } = resolveModel(modelToUse);
       if (!isCua) {
-        throw new Error(
-          "To use the computer use agent, please provide a CUA model in the agent constructor or stagehand config. Try one of our supported CUA models: " + AVAILABLE_CUA_MODELS.join(", ")
-        );
+        throw new CuaModelRequiredError(AVAILABLE_CUA_MODELS);
       }
       const agentConfigSignature2 = this.agentCache.buildConfigSignature(options);
       return {
@@ -40940,9 +41096,7 @@ var _V3 = class _V3 {
           return withInstanceLogContext(this.instanceId, () => __async(this, null, function* () {
             var _a2, _b2;
             if ((options == null ? void 0 : options.integrations) && !this.experimental) {
-              throw new Error(
-                "MCP integrations are experimental. Enable experimental: true in V3 options."
-              );
+              throw new ExperimentalNotConfiguredError("MCP integrations");
             }
             const tools = (options == null ? void 0 : options.integrations) ? yield resolveTools(options.integrations, options.tools) : (_a2 = options == null ? void 0 : options.tools) != null ? _a2 : {};
             const handler = new V3CuaAgentHandler(
@@ -41023,8 +41177,8 @@ Do not ask follow up questions, the user will trust your judgement.`
         return withInstanceLogContext(this.instanceId, () => __async(this, null, function* () {
           var _a2, _b2;
           if (((options == null ? void 0 : options.integrations) || (options == null ? void 0 : options.tools)) && !this.experimental) {
-            throw new Error(
-              "MCP integrations and custom tools are experimental. Enable experimental: true in V3 options."
+            throw new ExperimentalNotConfiguredError(
+              "MCP integrations and custom tools"
             );
           }
           const tools = (options == null ? void 0 : options.integrations) ? yield resolveTools(options.integrations, options.tools) : (_a2 = options == null ? void 0 : options.tools) != null ? _a2 : {};
@@ -41108,13 +41262,14 @@ function isObserveResult(v) {
 
 // lib/v3Evaluator.ts
 var import_dotenv2 = __toESM(require("dotenv"));
-var import_zod23 = require("zod");
+var import_v318 = require("zod/v3");
+init_sdkErrors();
 import_dotenv2.default.config();
-var EvaluationSchema = import_zod23.z.object({
-  evaluation: import_zod23.z.enum(["YES", "NO"]),
-  reasoning: import_zod23.z.string()
+var EvaluationSchema = import_v318.z.object({
+  evaluation: import_v318.z.enum(["YES", "NO"]),
+  reasoning: import_v318.z.string()
 });
-var BatchEvaluationSchema = import_zod23.z.array(EvaluationSchema);
+var BatchEvaluationSchema = import_v318.z.array(EvaluationSchema);
 var V3Evaluator = class {
   constructor(v3, modelName, modelClientOptions) {
     this.silentLogger = () => {
@@ -41139,9 +41294,14 @@ var V3Evaluator = class {
         screenshotDelayMs = 250,
         agentReasoning
       } = options;
-      if (!question) throw new Error("Question cannot be an empty string");
+      if (!question)
+        throw new StagehandInvalidArgumentError(
+          "Question cannot be an empty string"
+        );
       if (!answer && !screenshot)
-        throw new Error("Either answer (text) or screenshot must be provided");
+        throw new StagehandInvalidArgumentError(
+          "Either answer (text) or screenshot must be provided"
+        );
       if (Array.isArray(screenshot)) {
         return this._evaluateWithMultipleScreenshots({
           question,
@@ -41209,7 +41369,10 @@ ${agentReasoning}` : question
         systemPrompt = "You are an expert evaluator that returns YES or NO with a concise reasoning.",
         screenshotDelayMs = 250
       } = options;
-      if (!(questions == null ? void 0 : questions.length)) throw new Error("Questions array cannot be empty");
+      if (!(questions == null ? void 0 : questions.length))
+        throw new StagehandInvalidArgumentError(
+          "Questions array cannot be empty"
+        );
       yield new Promise((r) => setTimeout(r, screenshotDelayMs));
       let imageBuffer;
       if (screenshot) {
@@ -41280,9 +41443,14 @@ You will be given multiple questions${screenshot ? " with a screenshot" : ""}. $
         ${agentReasoning ? "The agent's reasoning provides crucial context about what actions were attempted, what was observed, and the decision-making process. Use this alongside the visual evidence to make a comprehensive evaluation." : ""}
         Today's date is ${(/* @__PURE__ */ new Date()).toLocaleDateString()}`
       } = options;
-      if (!question) throw new Error("Question cannot be an empty string");
+      if (!question)
+        throw new StagehandInvalidArgumentError(
+          "Question cannot be an empty string"
+        );
       if (!screenshots || screenshots.length === 0)
-        throw new Error("At least one screenshot must be provided");
+        throw new StagehandInvalidArgumentError(
+          "At least one screenshot must be provided"
+        );
       const llmClient = this.getClient();
       const imageContents = screenshots.map((s) => ({
         type: "image_url",
@@ -41336,9 +41504,12 @@ I'm providing ${screenshots.length} screenshots showing the progression of the t
   AnnotatedScreenshotText,
   BrowserbaseSessionNotFoundError,
   CaptchaTimeoutError,
+  ConnectionTimeoutError,
   ConsoleMessage,
   ContentFrameNotFoundError,
   CreateChatCompletionResponseError,
+  CuaModelRequiredError,
+  ElementNotVisibleError,
   ExperimentalApiConflictError,
   ExperimentalNotConfiguredError,
   HandlerNotInitializedError,
@@ -41349,7 +41520,10 @@ I'm providing ${screenshots.length} screenshots showing the progression of the t
   MCPConnectionError,
   MissingEnvironmentVariableError,
   MissingLLMConfigurationError,
+  PageNotFoundError,
   Response,
+  ResponseBodyError,
+  ResponseParseError,
   Stagehand,
   StagehandAPIError,
   StagehandAPIUnauthorizedError,
@@ -41372,6 +41546,7 @@ I'm providing ${screenshots.length} screenshots showing the progression of the t
   StagehandShadowRootMissingError,
   StagehandShadowSegmentEmptyError,
   StagehandShadowSegmentNotFoundError,
+  TimeoutError,
   UnsupportedAISDKModelProviderError,
   UnsupportedModelError,
   UnsupportedModelProviderError,