@browserbasehq/stagehand 2.5.6 → 2.5.8

package/dist/index.d.ts

@@ -978,6 +978,10 @@ declare class InvalidAISDKModelFormatError extends StagehandError {
 declare class StagehandNotInitializedError extends StagehandError {
     constructor(prop: string);
 }
+declare class StagehandTargetClosedError extends StagehandError {
+    causedBy?: Error | StagehandError;
+    constructor(error?: unknown);
+}
 declare class BrowserbaseSessionNotFoundError extends StagehandError {
     constructor();
 }
@@ -1244,4 +1248,4 @@ declare class Stagehand {
     };
 }
 
-export { AISdkClient, type ActOptions, type ActResult, type ActToolResult, type ActionExecutionResult, type AgentAction$1 as AgentAction, type AgentClientOptions, type AgentConfig, type AgentExecuteOptions$1 as AgentExecuteOptions, type AgentExecuteParams, type AgentExecutionOptions, type AgentHandlerOptions, type AgentInstance, type AgentOptions$1 as AgentOptions, type AgentProviderType, type AgentResult$1 as AgentResult, AgentScreenshotProviderError, type AgentType, AnnotatedScreenshotText, type AnthropicContentBlock, type AnthropicJsonSchemaObject, type AnthropicMessage, type AnthropicTextBlock, type AnthropicToolResult, type AvailableModel, AvailableModelSchema, type Browser, type BrowserContext, type BrowserResult, BrowserbaseSessionNotFoundError, CaptchaTimeoutError, type ChatCompletionOptions, type ChatMessage, type ChatMessageContent, type ChatMessageImageContent, type ChatMessageTextContent, type ClientOptions, type ComputerCallItem, type ConstructorParams, ContentFrameNotFoundError, type CreateChatCompletionOptions, CreateChatCompletionResponseError, ExperimentalApiConflictError, ExperimentalNotConfiguredError, type ExtractOptions, type ExtractResult, type FunctionCallItem, type GotoOptions, HandlerNotInitializedError, type HistoryEntry, type InitResult, InvalidAISDKModelFormatError, LLMClient, type LLMResponse, LLMResponseError, LOG_LEVEL_NAMES, type LocalBrowserLaunchOptions, type LogLevel, type LogLine, type Logger, MCPConnectionError, MissingEnvironmentVariableError, MissingLLMConfigurationError, type ModelProvider, type ObserveOptions, type ObserveResult$1 as ObserveResult, type Page, PlaywrightCommandException, PlaywrightCommandMethodNotSupportedException, type ResponseInputItem, type ResponseItem, Stagehand, StagehandAPIError, StagehandAPIUnauthorizedError, StagehandClickError, StagehandDefaultError, StagehandDomProcessError, StagehandElementNotFoundError, StagehandEnvironmentError, StagehandError, StagehandEvalError, StagehandFunctionName, StagehandHttpError, StagehandIframeError, StagehandInitError, StagehandInvalidArgumentError, type StagehandMetrics, StagehandMissingArgumentError, StagehandNotInitializedError, StagehandResponseBodyError, StagehandResponseParseError, type StagehandScreenshotOptions, StagehandServerError, StagehandShadowRootMissingError, StagehandShadowSegmentEmptyError, StagehandShadowSegmentNotFoundError, type ToolUseItem, type TreeResult, UnsupportedAISDKModelProviderError, UnsupportedModelError, UnsupportedModelProviderError, XPathResolutionError, type ZodPathSegments, ZodSchemaValidationError, connectToMCPServer, defaultExtractSchema, getAccessibilityTree, pageTextSchema };
+export { AISdkClient, type ActOptions, type ActResult, type ActToolResult, type ActionExecutionResult, type AgentAction$1 as AgentAction, type AgentClientOptions, type AgentConfig, type AgentExecuteOptions$1 as AgentExecuteOptions, type AgentExecuteParams, type AgentExecutionOptions, type AgentHandlerOptions, type AgentInstance, type AgentOptions$1 as AgentOptions, type AgentProviderType, type AgentResult$1 as AgentResult, AgentScreenshotProviderError, type AgentType, AnnotatedScreenshotText, type AnthropicContentBlock, type AnthropicJsonSchemaObject, type AnthropicMessage, type AnthropicTextBlock, type AnthropicToolResult, type AvailableModel, AvailableModelSchema, type Browser, type BrowserContext, type BrowserResult, BrowserbaseSessionNotFoundError, CaptchaTimeoutError, type ChatCompletionOptions, type ChatMessage, type ChatMessageContent, type ChatMessageImageContent, type ChatMessageTextContent, type ClientOptions, type ComputerCallItem, type ConstructorParams, ContentFrameNotFoundError, type CreateChatCompletionOptions, CreateChatCompletionResponseError, ExperimentalApiConflictError, ExperimentalNotConfiguredError, type ExtractOptions, type ExtractResult, type FunctionCallItem, type GotoOptions, HandlerNotInitializedError, type HistoryEntry, type InitResult, InvalidAISDKModelFormatError, LLMClient, type LLMResponse, LLMResponseError, LOG_LEVEL_NAMES, type LocalBrowserLaunchOptions, type LogLevel, type LogLine, type Logger, MCPConnectionError, MissingEnvironmentVariableError, MissingLLMConfigurationError, type ModelProvider, type ObserveOptions, type ObserveResult$1 as ObserveResult, type Page, PlaywrightCommandException, PlaywrightCommandMethodNotSupportedException, type ResponseInputItem, type ResponseItem, Stagehand, StagehandAPIError, StagehandAPIUnauthorizedError, StagehandClickError, StagehandDefaultError, StagehandDomProcessError, StagehandElementNotFoundError, StagehandEnvironmentError, StagehandError, StagehandEvalError, StagehandFunctionName, StagehandHttpError, StagehandIframeError, StagehandInitError, StagehandInvalidArgumentError, type StagehandMetrics, StagehandMissingArgumentError, StagehandNotInitializedError, StagehandResponseBodyError, StagehandResponseParseError, type StagehandScreenshotOptions, StagehandServerError, StagehandShadowRootMissingError, StagehandShadowSegmentEmptyError, StagehandShadowSegmentNotFoundError, StagehandTargetClosedError, type ToolUseItem, type TreeResult, UnsupportedAISDKModelProviderError, UnsupportedModelError, UnsupportedModelProviderError, XPathResolutionError, type ZodPathSegments, ZodSchemaValidationError, connectToMCPServer, defaultExtractSchema, getAccessibilityTree, pageTextSchema };

package/dist/index.js

@@ -466,6 +466,7 @@ __export(index_exports, {
   StagehandShadowRootMissingError: () => StagehandShadowRootMissingError,
   StagehandShadowSegmentEmptyError: () => StagehandShadowSegmentEmptyError,
   StagehandShadowSegmentNotFoundError: () => StagehandShadowSegmentNotFoundError,
+  StagehandTargetClosedError: () => StagehandTargetClosedError,
   UnsupportedAISDKModelProviderError: () => UnsupportedAISDKModelProviderError,
   UnsupportedModelError: () => UnsupportedModelError,
   UnsupportedModelProviderError: () => UnsupportedModelProviderError,
@@ -494,7 +495,7 @@ var StagehandFunctionName = /* @__PURE__ */ ((StagehandFunctionName2) => {
 })(StagehandFunctionName || {});
 
 // lib/version.ts
-var STAGEHAND_VERSION = "2.5.6";
+var STAGEHAND_VERSION = "2.5.8";
 
 // types/stagehandErrors.ts
 var StagehandError = class extends Error {
@@ -568,6 +569,15 @@ var StagehandNotInitializedError = class extends StagehandError {
     );
   }
 };
+var StagehandTargetClosedError = class extends StagehandError {
+  constructor(error) {
+    const message = error instanceof Error || error instanceof StagehandError ? `Target closed before CDP session could attach: ${error.message}` : "Target closed before CDP session could attach";
+    super(message);
+    if (error instanceof Error || error instanceof StagehandError) {
+      this.causedBy = error;
+    }
+  }
+};
 var BrowserbaseSessionNotFoundError = class extends StagehandError {
   constructor() {
     super("No Browserbase session ID found");
@@ -2154,6 +2164,18 @@ var ID_PATTERN = /^\d+-\d+$/;
 // lib/utils.ts
 var import_genai = require("@google/genai");
 var import_v33 = require("zod/v3");
+var TARGET_GONE_ERROR_SNIPPETS = [
+  "No target with given id found",
+  "Target closed"
+];
+function isTargetGoneError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return TARGET_GONE_ERROR_SNIPPETS.some((snippet) => msg.includes(snippet));
+}
+function isTargetGone(target) {
+  if (typeof target.isClosed === "function" && target.isClosed()) return true;
+  return typeof target.isDetached === "function" && target.isDetached();
+}
 function validateZodSchema(schema, data) {
   const result = schema.safeParse(data);
   if (result.success) {
@@ -4624,12 +4646,24 @@ var StagehandPage = class _StagehandPage {
     return __async(this, arguments, function* (target = this.page) {
       var _a15;
       const cached = this.cdpClients.get(target);
-      if (cached) return cached;
+      if (cached) {
+        if (isTargetGone(target)) {
+          this.cdpClients.delete(target);
+          throw new StagehandTargetClosedError();
+        }
+        return cached;
+      }
+      if (isTargetGone(target)) {
+        throw new StagehandTargetClosedError();
+      }
       try {
         const session = yield this.context.newCDPSession(target);
         this.cdpClients.set(target, session);
         return session;
       } catch (err) {
+        if (isTargetGone(target) || isTargetGoneError(err)) {
+          throw new StagehandTargetClosedError(err);
+        }
         const msg = (_a15 = err.message) != null ? _a15 : "";
         if (msg.includes("does not have a separate CDP session")) {
           const rootSession = yield this.getCDPClient(this.page);
@@ -4726,6 +4760,9 @@ var _StagehandContext = class _StagehandContext {
   }
   createStagehandPage(page) {
     return __async(this, null, function* () {
+      if (page.isClosed()) {
+        throw new StagehandTargetClosedError();
+      }
       const stagehandPage = yield new StagehandPage(
         page,
         this.stagehand,
@@ -4766,9 +4803,18 @@ var _StagehandContext = class _StagehandContext {
       }));
       const existingPages = context.pages();
       for (const page of existingPages) {
-        const stagehandPage = yield instance.createStagehandPage(page);
+        if (page.isClosed()) continue;
+        let stagehandPage;
+        try {
+          stagehandPage = yield instance.createStagehandPage(page);
+        } catch (err) {
+          if (err instanceof StagehandTargetClosedError || isTargetGoneError(err) || page.isClosed()) {
+            continue;
+          }
+          throw err;
+        }
         yield instance.attachFrameNavigatedListener(page);
-        if (!instance.activeStagehandPage) {
+        if (!instance.activeStagehandPage && stagehandPage) {
           instance.setActivePage(stagehandPage);
         }
       }
@@ -4817,9 +4863,17 @@ var _StagehandContext = class _StagehandContext {
   }
   handleNewPlaywrightPage(pwPage) {
     return __async(this, null, function* () {
+      if (pwPage.isClosed()) return;
       let stagehandPage = this.pageMap.get(pwPage);
       if (!stagehandPage) {
-        stagehandPage = yield this.createStagehandPage(pwPage);
+        try {
+          stagehandPage = yield this.createStagehandPage(pwPage);
+        } catch (err) {
+          if (err instanceof StagehandTargetClosedError || isTargetGoneError(err) || pwPage.isClosed()) {
+            return;
+          }
+          throw err;
+        }
       }
       this.setActivePage(stagehandPage);
     });
@@ -4828,7 +4882,14 @@ var _StagehandContext = class _StagehandContext {
     return __async(this, null, function* () {
       const shPage = this.pageMap.get(pwPage);
       if (!shPage) return;
-      const session = yield this.intContext.newCDPSession(pwPage);
+      if (pwPage.isClosed()) return;
+      let session;
+      try {
+        session = yield this.intContext.newCDPSession(pwPage);
+      } catch (err) {
+        if (pwPage.isClosed() || isTargetGoneError(err)) return;
+        throw err;
+      }
       yield session.send("Page.enable");
       pwPage.once("close", () => {
         if (shPage.frameId) this.unregisterFrameId(shPage.frameId);
@@ -23452,51 +23513,74 @@ var createScrollTool = (stagehand) => (0, import_ai11.tool)({
 // lib/agent/tools/extract.ts
 var import_ai12 = require("ai");
 var import_v314 = require("zod/v3");
-function evaluateZodSchema(schemaStr, logger) {
-  try {
-    const schemaFunction = new Function("z", `return ${schemaStr}`);
-    return schemaFunction(import_v314.z);
-  } catch (error) {
-    logger == null ? void 0 : logger({
-      category: "extract",
-      message: `Failed to evaluate schema string, using z.any(): ${error}`,
-      level: 1,
-      auxiliary: {
-        error: {
-          value: error,
-          type: "string"
+function jsonSchemaToZod2(schema) {
+  switch (schema.type) {
+    case "object": {
+      const shape = {};
+      if (schema.properties) {
+        for (const [key, value] of Object.entries(schema.properties)) {
+          shape[key] = jsonSchemaToZod2(value);
         }
       }
-    });
-    return import_v314.z.any();
+      return import_v314.z.object(shape);
+    }
+    case "array":
+      return import_v314.z.array(schema.items ? jsonSchemaToZod2(schema.items) : import_v314.z.any());
+    case "string": {
+      let s = import_v314.z.string();
+      if (schema.format === "url") s = s.url();
+      if (schema.format === "email") s = s.email();
+      if (schema.format === "uuid") s = s.uuid();
+      if (schema.enum && schema.enum.length > 0)
+        return import_v314.z.enum(schema.enum);
+      return s;
+    }
+    case "number":
+    case "integer":
+      return import_v314.z.number();
+    case "boolean":
+      return import_v314.z.boolean();
+    case "null":
+      return import_v314.z.null();
+    default:
+      return import_v314.z.any();
   }
 }
-var createExtractTool = (stagehand, executionModel, logger) => (0, import_ai12.tool)({
+var createExtractTool = (stagehand, executionModel) => (0, import_ai12.tool)({
   description: `Extract structured data from the current page based on a provided schema.
     
     USAGE GUIDELINES:
     - Keep schemas MINIMAL - only include fields essential for the task
-    - IMPORANT: only use this if explicitly asked for structured output. In most scenarios, you should use the aria tree tool over this. 
-    - If you need to extract a link, make sure the type defintion follows the format of z.string().url()
+    - IMPORTANT: only use this if explicitly asked for structured output. In most scenarios, you should use the aria tree tool over this.
+    - For URL fields, use format: "url"
+    
     EXAMPLES:
     1. Extract a single value:
        instruction: "extract the product price"
-       schema: "z.object({ price: z.number()})"
+       schema: { type: "object", properties: { price: { type: "number" } } }
     
     2. Extract multiple fields:
        instruction: "extract product name and price"
-       schema: "z.object({ name: z.string(), price: z.number() })"
+       schema: { type: "object", properties: { name: { type: "string" }, price: { type: "number" } } }
     
     3. Extract arrays:
        instruction: "extract all product names and prices"
-       schema: "z.object({ products: z.array(z.object({ name: z.string(), price: z.number() })) })"`,
+       schema: { type: "object", properties: { products: { type: "array", items: { type: "object", properties: { name: { type: "string" }, price: { type: "number" } } } } } }
+    
+    4. Extract a URL:
+       instruction: "extract the link"
+       schema: { type: "object", properties: { url: { type: "string", format: "url" } } }`,
   parameters: import_v314.z.object({
     instruction: import_v314.z.string().describe(
       "Clear instruction describing what data to extract from the page"
     ),
-    schema: import_v314.z.string().describe(
-      'Zod schema as a string (e.g., "z.object({ price: z.number() })")'
-    )
+    schema: import_v314.z.object({
+      type: import_v314.z.string().optional(),
+      properties: import_v314.z.record(import_v314.z.string(), import_v314.z.unknown()).optional(),
+      items: import_v314.z.unknown().optional(),
+      enum: import_v314.z.array(import_v314.z.string()).optional(),
+      format: import_v314.z.enum(["url", "email", "uuid"]).optional()
+    }).passthrough().describe("JSON Schema object describing the structure to extract")
   }),
   execute: (_0) => __async(null, [_0], function* ({ instruction, schema }) {
     try {
@@ -23509,14 +23593,13 @@ var createExtractTool = (stagehand, executionModel, logger) => (0, import_ai12.t
             value: instruction,
             type: "string"
           },
-          // TODO: check if we want to log this
           schema: {
-            value: schema,
+            value: JSON.stringify(schema),
             type: "object"
           }
         }
       });
-      const zodSchema = evaluateZodSchema(schema, logger);
+      const zodSchema = jsonSchemaToZod2(schema);
       const schemaObject = zodSchema instanceof import_v314.z.ZodObject ? zodSchema : import_v314.z.object({ result: zodSchema });
       const result = yield stagehand.page.extract(__spreadValues({
         instruction,
@@ -23545,7 +23628,7 @@ function createAgentTools(stagehand, options) {
     act: createActTool(stagehand, executionModel),
     ariaTree: createAriaTreeTool(stagehand),
     close: createCloseTool(),
-    extract: createExtractTool(stagehand, executionModel, options == null ? void 0 : options.logger),
+    extract: createExtractTool(stagehand, executionModel),
     fillForm: createFillFormTool(stagehand, executionModel),
     goto: createGotoTool(stagehand),
     navback: createNavBackTool(stagehand),
@@ -24945,6 +25028,7 @@ var Stagehand3 = class {
   StagehandShadowRootMissingError,
   StagehandShadowSegmentEmptyError,
   StagehandShadowSegmentNotFoundError,
+  StagehandTargetClosedError,
   UnsupportedAISDKModelProviderError,
   UnsupportedModelError,
   UnsupportedModelProviderError,

package/dist/lib/agent/tools/extract.d.ts

@@ -1,14 +1,47 @@
 import { z } from "zod/v3";
 import { Stagehand } from "../../index";
-import { LogLine } from "@/types/log";
-export declare const createExtractTool: (stagehand: Stagehand, executionModel?: string, logger?: (message: LogLine) => void) => import("ai/dist").Tool<z.ZodObject<{
+export declare const createExtractTool: (stagehand: Stagehand, executionModel?: string) => import("ai/dist").Tool<z.ZodObject<{
     instruction: z.ZodString;
-    schema: z.ZodString;
+    schema: z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        items: z.ZodOptional<z.ZodUnknown>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        format: z.ZodOptional<z.ZodEnum<["url", "email", "uuid"]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodOptional<z.ZodString>;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        items: z.ZodOptional<z.ZodUnknown>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        format: z.ZodOptional<z.ZodEnum<["url", "email", "uuid"]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodOptional<z.ZodString>;
+        properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        items: z.ZodOptional<z.ZodUnknown>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        format: z.ZodOptional<z.ZodEnum<["url", "email", "uuid"]>>;
+    }, z.ZodTypeAny, "passthrough">>;
 }, "strip", z.ZodTypeAny, {
-    schema?: string;
+    schema?: {
+        type?: string;
+        format?: "url" | "email" | "uuid";
+        properties?: Record<string, unknown>;
+        items?: unknown;
+        enum?: string[];
+    } & {
+        [k: string]: unknown;
+    };
     instruction?: string;
 }, {
-    schema?: string;
+    schema?: {
+        type?: string;
+        format?: "url" | "email" | "uuid";
+        properties?: Record<string, unknown>;
+        items?: unknown;
+        enum?: string[];
+    } & {
+        [k: string]: unknown;
+    };
     instruction?: string;
 }>, {
     success: boolean;
@@ -22,7 +55,15 @@ export declare const createExtractTool: (stagehand: Stagehand, executionModel?:
     data?: undefined;
 }> & {
     execute: (args: {
-        schema?: string;
+        schema?: {
+            type?: string;
+            format?: "url" | "email" | "uuid";
+            properties?: Record<string, unknown>;
+            items?: unknown;
+            enum?: string[];
+        } & {
+            [k: string]: unknown;
+        };
         instruction?: string;
     }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
         success: boolean;

package/dist/lib/agent/tools/index.d.ts

@@ -94,12 +94,46 @@ export declare function createAgentTools(stagehand: Stagehand, options?: AgentTo
     };
     extract: import("ai/dist").Tool<import("zod/v3").ZodObject<{
         instruction: import("zod/v3").ZodString;
-        schema: import("zod/v3").ZodString;
+        schema: import("zod/v3").ZodObject<{
+            type: import("zod/v3").ZodOptional<import("zod/v3").ZodString>;
+            properties: import("zod/v3").ZodOptional<import("zod/v3").ZodRecord<import("zod/v3").ZodString, import("zod/v3").ZodUnknown>>;
+            items: import("zod/v3").ZodOptional<import("zod/v3").ZodUnknown>;
+            enum: import("zod/v3").ZodOptional<import("zod/v3").ZodArray<import("zod/v3").ZodString, "many">>;
+            format: import("zod/v3").ZodOptional<import("zod/v3").ZodEnum<["url", "email", "uuid"]>>;
+        }, "passthrough", import("zod/v3").ZodTypeAny, import("zod/v3").objectOutputType<{
+            type: import("zod/v3").ZodOptional<import("zod/v3").ZodString>;
+            properties: import("zod/v3").ZodOptional<import("zod/v3").ZodRecord<import("zod/v3").ZodString, import("zod/v3").ZodUnknown>>;
+            items: import("zod/v3").ZodOptional<import("zod/v3").ZodUnknown>;
+            enum: import("zod/v3").ZodOptional<import("zod/v3").ZodArray<import("zod/v3").ZodString, "many">>;
+            format: import("zod/v3").ZodOptional<import("zod/v3").ZodEnum<["url", "email", "uuid"]>>;
+        }, import("zod/v3").ZodTypeAny, "passthrough">, import("zod/v3").objectInputType<{
+            type: import("zod/v3").ZodOptional<import("zod/v3").ZodString>;
+            properties: import("zod/v3").ZodOptional<import("zod/v3").ZodRecord<import("zod/v3").ZodString, import("zod/v3").ZodUnknown>>;
+            items: import("zod/v3").ZodOptional<import("zod/v3").ZodUnknown>;
+            enum: import("zod/v3").ZodOptional<import("zod/v3").ZodArray<import("zod/v3").ZodString, "many">>;
+            format: import("zod/v3").ZodOptional<import("zod/v3").ZodEnum<["url", "email", "uuid"]>>;
+        }, import("zod/v3").ZodTypeAny, "passthrough">>;
     }, "strip", import("zod/v3").ZodTypeAny, {
-        schema?: string;
+        schema?: {
+            type?: string;
+            format?: "url" | "email" | "uuid";
+            properties?: Record<string, unknown>;
+            items?: unknown;
+            enum?: string[];
+        } & {
+            [k: string]: unknown;
+        };
         instruction?: string;
     }, {
-        schema?: string;
+        schema?: {
+            type?: string;
+            format?: "url" | "email" | "uuid";
+            properties?: Record<string, unknown>;
+            items?: unknown;
+            enum?: string[];
+        } & {
+            [k: string]: unknown;
+        };
         instruction?: string;
     }>, {
         success: boolean;
@@ -113,7 +147,15 @@ export declare function createAgentTools(stagehand: Stagehand, options?: AgentTo
         data?: undefined;
     }> & {
         execute: (args: {
-            schema?: string;
+            schema?: {
+                type?: string;
+                format?: "url" | "email" | "uuid";
+                properties?: Record<string, unknown>;
+                items?: unknown;
+                enum?: string[];
+            } & {
+                [k: string]: unknown;
+            };
             instruction?: string;
         }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
             success: boolean;

package/dist/lib/utils.d.ts

@@ -3,6 +3,12 @@ import { z, ZodTypeAny } from "zod/v3";
 import { LogLine } from "../types/log";
 import { ModelProvider } from "../types/model";
 import { ZodPathSegments } from "../types/stagehand";
+export declare const TARGET_GONE_ERROR_SNIPPETS: string[];
+export declare function isTargetGoneError(err: unknown): boolean;
+export declare function isTargetGone(target: {
+    isClosed?: () => boolean;
+    isDetached?: () => boolean;
+}): boolean;
 export declare function validateZodSchema(schema: z.ZodTypeAny, data: unknown): boolean;
 /**
  * Detects if the code is running in the Bun runtime environment.

package/dist/lib/version.d.ts

@@ -2,4 +2,4 @@
  * AUTO-GENERATED — DO NOT EDIT BY HAND
  *  Run `pnpm run gen-version` to refresh.
  */
-export declare const STAGEHAND_VERSION: "2.5.6";
+export declare const STAGEHAND_VERSION: "2.5.8";

package/dist/types/stagehandErrors.d.ts

@@ -27,6 +27,10 @@ export declare class InvalidAISDKModelFormatError extends StagehandError {
 export declare class StagehandNotInitializedError extends StagehandError {
     constructor(prop: string);
 }
+export declare class StagehandTargetClosedError extends StagehandError {
+    causedBy?: Error | StagehandError;
+    constructor(error?: unknown);
+}
 export declare class BrowserbaseSessionNotFoundError extends StagehandError {
     constructor();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserbasehq/stagehand",
-  "version": "2.5.6",
+  "version": "2.5.8",
   "description": "An AI web browsing framework focused on simplicity and extensibility.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",