@browserbasehq/orca 3.0.9-alpha-4 → 3.1.0-patch.1

package/dist/esm/tests/page-snapshot.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../tests/page-snapshot.test.ts"],
+  "sourcesContent": ["import { afterEach, describe, expect, it, vi } from \"vitest\";\nimport { promises as fs } from \"fs\";\nimport { Page } from \"../lib/v3/understudy/page.js\";\nimport * as snapshotModule from \"../lib/v3/understudy/a11y/snapshot/index.js\";\nimport type { HybridSnapshot } from \"../lib/v3/types/private/index.js\";\n\nconst baseSnapshot: HybridSnapshot = {\n  combinedTree: \"tree\",\n  combinedXpathMap: {},\n  combinedUrlMap: {},\n  perFrame: [],\n};\n\ndescribe(\"Page.snapshot\", () => {\n  afterEach(() => {\n    vi.restoreAllMocks();\n  });\n\n  it(\"forwards the includeIframes flag to captureHybridSnapshot\", async () => {\n    vi.spyOn(fs, \"writeFile\").mockResolvedValue();\n    const captureSpy = vi\n      .spyOn(snapshotModule, \"captureHybridSnapshot\")\n      .mockResolvedValue(baseSnapshot);\n\n    const fakePage = {} as Page;\n    await Page.prototype.snapshot.call(fakePage, { includeIframes: false });\n\n    expect(captureSpy).toHaveBeenCalledWith(fakePage, {\n      pierceShadow: true,\n      includeIframes: false,\n    });\n  });\n\n  it(\"falls back to default iframe inclusion when option is omitted\", async () => {\n    vi.spyOn(fs, \"writeFile\").mockResolvedValue();\n    const captureSpy = vi\n      .spyOn(snapshotModule, \"captureHybridSnapshot\")\n      .mockResolvedValue(baseSnapshot);\n\n    const fakePage = {} as Page;\n    await Page.prototype.snapshot.call(fakePage);\n\n    expect(captureSpy).toHaveBeenCalledWith(fakePage, {\n      pierceShadow: true,\n      includeIframes: undefined,\n    });\n  });\n});\n"],
+  "mappings": "AAAA,SAAS,WAAW,UAAU,QAAQ,IAAI,UAAU;AACpD,SAAS,YAAY,UAAU;AAC/B,SAAS,YAAY;AACrB,YAAY,oBAAoB;AAGhC,MAAM,eAA+B;AAAA,EACnC,cAAc;AAAA,EACd,kBAAkB,CAAC;AAAA,EACnB,gBAAgB,CAAC;AAAA,EACjB,UAAU,CAAC;AACb;AAEA,SAAS,iBAAiB,MAAM;AAC9B,YAAU,MAAM;AACd,OAAG,gBAAgB;AAAA,EACrB,CAAC;AAED,KAAG,6DAA6D,YAAY;AAC1E,OAAG,MAAM,IAAI,WAAW,EAAE,kBAAkB;AAC5C,UAAM,aAAa,GAChB,MAAM,gBAAgB,uBAAuB,EAC7C,kBAAkB,YAAY;AAEjC,UAAM,WAAW,CAAC;AAClB,UAAM,KAAK,UAAU,SAAS,KAAK,UAAU,EAAE,gBAAgB,MAAM,CAAC;AAEtE,WAAO,UAAU,EAAE,qBAAqB,UAAU;AAAA,MAChD,cAAc;AAAA,MACd,gBAAgB;AAAA,IAClB,CAAC;AAAA,EACH,CAAC;AAED,KAAG,iEAAiE,YAAY;AAC9E,OAAG,MAAM,IAAI,WAAW,EAAE,kBAAkB;AAC5C,UAAM,aAAa,GAChB,MAAM,gBAAgB,uBAAuB,EAC7C,kBAAkB,YAAY;AAEjC,UAAM,WAAW,CAAC;AAClB,UAAM,KAAK,UAAU,SAAS,KAAK,QAAQ;AAE3C,WAAO,UAAU,EAAE,qBAAqB,UAAU;AAAA,MAChD,cAAc;AAAA,MACd,gBAAgB;AAAA,IAClB,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/esm/tests/public-api/export-surface.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import StagehandDefaultExport, * as Stagehand from "@browserbasehq/stagehand";
+import { publicErrorTypes } from "./public-error-types.test.js";
+const publicApiShape = {
+  __internalMaybeRunShutdownSupervisorFromArgv: Stagehand.__internalMaybeRunShutdownSupervisorFromArgv,
+  __internalCreateInMemoryAgentCacheHandle: Stagehand.__internalCreateInMemoryAgentCacheHandle,
+  AISdkClient: Stagehand.AISdkClient,
+  Api: Stagehand.Api,
+  AVAILABLE_CUA_MODELS: Stagehand.AVAILABLE_CUA_MODELS,
+  AgentProvider: Stagehand.AgentProvider,
+  AnnotatedScreenshotText: Stagehand.AnnotatedScreenshotText,
+  ConsoleMessage: Stagehand.ConsoleMessage,
+  CustomOpenAIClient: Stagehand.CustomOpenAIClient,
+  LLMClient: Stagehand.LLMClient,
+  LOG_LEVEL_NAMES: Stagehand.LOG_LEVEL_NAMES,
+  Response: Stagehand.Response,
+  Stagehand: Stagehand.Stagehand,
+  V3: Stagehand.V3,
+  V3Evaluator: Stagehand.V3Evaluator,
+  V3FunctionName: Stagehand.V3FunctionName,
+  connectToMCPServer: Stagehand.connectToMCPServer,
+  default: StagehandDefaultExport,
+  defaultExtractSchema: Stagehand.defaultExtractSchema,
+  getAISDKLanguageModel: Stagehand.getAISDKLanguageModel,
+  getZodType: Stagehand.getZodType,
+  injectUrls: Stagehand.injectUrls,
+  isRunningInBun: Stagehand.isRunningInBun,
+  isZod3Schema: Stagehand.isZod3Schema,
+  isZod4Schema: Stagehand.isZod4Schema,
+  jsonSchemaToZod: Stagehand.jsonSchemaToZod,
+  loadApiKeyFromEnv: Stagehand.loadApiKeyFromEnv,
+  localBrowserLaunchOptionsSchema: Stagehand.localBrowserLaunchOptionsSchema,
+  modelToAgentProviderMap: Stagehand.modelToAgentProviderMap,
+  pageTextSchema: Stagehand.pageTextSchema,
+  providerEnvVarMap: Stagehand.providerEnvVarMap,
+  toGeminiSchema: Stagehand.toGeminiSchema,
+  toJsonSchema: Stagehand.toJsonSchema,
+  tool: Stagehand.tool,
+  transformSchema: Stagehand.transformSchema,
+  trimTrailingTextNode: Stagehand.trimTrailingTextNode,
+  validateZodSchema: Stagehand.validateZodSchema,
+  ...publicErrorTypes
+};
+describe("Stagehand public API export surface", () => {
+  it("public API shape matches module exports", () => {
+    const _check = publicApiShape;
+  });
+  it("does not expose unexpected top-level exports", () => {
+    const expected = Object.keys(publicApiShape).sort();
+    const actual = Object.keys(Stagehand).sort();
+    expect(actual).toStrictEqual(expected);
+  });
+});
+//# sourceMappingURL=export-surface.test.js.map

package/dist/esm/tests/public-api/export-surface.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../tests/public-api/export-surface.test.ts"],
+  "sourcesContent": ["import { describe, expect, it } from \"vitest\";\nimport StagehandDefaultExport, * as Stagehand from \"@browserbasehq/stagehand\";\nimport { publicErrorTypes } from \"./public-error-types.test.js\";\n\n// Type matcher guidelines:\n//\n// toEqualTypeOf \u2013 Default. Assert full, deep type equality; any type change should fail.\n//   e.g. expectTypeOf<ReturnType<typeof foo>>().toEqualTypeOf<FooResult>()\n//\n// toMatchObjectType \u2013 Assert (part of) an object's shape while allowing extra fields.\n//   e.g. expectTypeOf(user).toMatchObjectType<{ id: string; email: string }>()\n//\n// toExtend \u2013 Assert that a type is compatible with a broader contract (assignable/extends).\n//   e.g. expectTypeOf<User>().toExtend<BaseUser>()\n\nconst publicApiShape = {\n  __internalMaybeRunShutdownSupervisorFromArgv:\n    Stagehand.__internalMaybeRunShutdownSupervisorFromArgv,\n  __internalCreateInMemoryAgentCacheHandle:\n    Stagehand.__internalCreateInMemoryAgentCacheHandle,\n  AISdkClient: Stagehand.AISdkClient,\n  Api: Stagehand.Api,\n  AVAILABLE_CUA_MODELS: Stagehand.AVAILABLE_CUA_MODELS,\n  AgentProvider: Stagehand.AgentProvider,\n  AnnotatedScreenshotText: Stagehand.AnnotatedScreenshotText,\n  ConsoleMessage: Stagehand.ConsoleMessage,\n  CustomOpenAIClient: Stagehand.CustomOpenAIClient,\n  LLMClient: Stagehand.LLMClient,\n  LOG_LEVEL_NAMES: Stagehand.LOG_LEVEL_NAMES,\n  Response: Stagehand.Response,\n  Stagehand: Stagehand.Stagehand,\n  V3: Stagehand.V3,\n  V3Evaluator: Stagehand.V3Evaluator,\n  V3FunctionName: Stagehand.V3FunctionName,\n  connectToMCPServer: Stagehand.connectToMCPServer,\n  default: StagehandDefaultExport,\n  defaultExtractSchema: Stagehand.defaultExtractSchema,\n  getAISDKLanguageModel: Stagehand.getAISDKLanguageModel,\n  getZodType: Stagehand.getZodType,\n  injectUrls: Stagehand.injectUrls,\n  isRunningInBun: Stagehand.isRunningInBun,\n  isZod3Schema: Stagehand.isZod3Schema,\n  isZod4Schema: Stagehand.isZod4Schema,\n  jsonSchemaToZod: Stagehand.jsonSchemaToZod,\n  loadApiKeyFromEnv: Stagehand.loadApiKeyFromEnv,\n  localBrowserLaunchOptionsSchema: Stagehand.localBrowserLaunchOptionsSchema,\n  modelToAgentProviderMap: Stagehand.modelToAgentProviderMap,\n  pageTextSchema: Stagehand.pageTextSchema,\n  providerEnvVarMap: Stagehand.providerEnvVarMap,\n  toGeminiSchema: Stagehand.toGeminiSchema,\n  toJsonSchema: Stagehand.toJsonSchema,\n  tool: Stagehand.tool,\n  transformSchema: Stagehand.transformSchema,\n  trimTrailingTextNode: Stagehand.trimTrailingTextNode,\n  validateZodSchema: Stagehand.validateZodSchema,\n  ...publicErrorTypes,\n} as const;\n\ntype StagehandExports = typeof Stagehand & {\n  default: typeof StagehandDefaultExport;\n};\n\ntype PublicAPI = {\n  [K in keyof typeof publicApiShape]: StagehandExports[K];\n};\n\ndescribe(\"Stagehand public API export surface\", () => {\n  it(\"public API shape matches module exports\", () => {\n    const _check: PublicAPI = publicApiShape;\n    void _check;\n  });\n\n  it(\"does not expose unexpected top-level exports\", () => {\n    const expected = Object.keys(publicApiShape).sort();\n    const actual = Object.keys(Stagehand).sort();\n    expect(actual).toStrictEqual(expected);\n  });\n});\n"],
+  "mappings": "AAAA,SAAS,UAAU,QAAQ,UAAU;AACrC,OAAO,6BAA6B,eAAe;AACnD,SAAS,wBAAwB;AAajC,MAAM,iBAAiB;AAAA,EACrB,8CACE,UAAU;AAAA,EACZ,0CACE,UAAU;AAAA,EACZ,aAAa,UAAU;AAAA,EACvB,KAAK,UAAU;AAAA,EACf,sBAAsB,UAAU;AAAA,EAChC,eAAe,UAAU;AAAA,EACzB,yBAAyB,UAAU;AAAA,EACnC,gBAAgB,UAAU;AAAA,EAC1B,oBAAoB,UAAU;AAAA,EAC9B,WAAW,UAAU;AAAA,EACrB,iBAAiB,UAAU;AAAA,EAC3B,UAAU,UAAU;AAAA,EACpB,WAAW,UAAU;AAAA,EACrB,IAAI,UAAU;AAAA,EACd,aAAa,UAAU;AAAA,EACvB,gBAAgB,UAAU;AAAA,EAC1B,oBAAoB,UAAU;AAAA,EAC9B,SAAS;AAAA,EACT,sBAAsB,UAAU;AAAA,EAChC,uBAAuB,UAAU;AAAA,EACjC,YAAY,UAAU;AAAA,EACtB,YAAY,UAAU;AAAA,EACtB,gBAAgB,UAAU;AAAA,EAC1B,cAAc,UAAU;AAAA,EACxB,cAAc,UAAU;AAAA,EACxB,iBAAiB,UAAU;AAAA,EAC3B,mBAAmB,UAAU;AAAA,EAC7B,iCAAiC,UAAU;AAAA,EAC3C,yBAAyB,UAAU;AAAA,EACnC,gBAAgB,UAAU;AAAA,EAC1B,mBAAmB,UAAU;AAAA,EAC7B,gBAAgB,UAAU;AAAA,EAC1B,cAAc,UAAU;AAAA,EACxB,MAAM,UAAU;AAAA,EAChB,iBAAiB,UAAU;AAAA,EAC3B,sBAAsB,UAAU;AAAA,EAChC,mBAAmB,UAAU;AAAA,EAC7B,GAAG;AACL;AAUA,SAAS,uCAAuC,MAAM;AACpD,KAAG,2CAA2C,MAAM;AAClD,UAAM,SAAoB;AAAA,EAE5B,CAAC;AAED,KAAG,gDAAgD,MAAM;AACvD,UAAM,WAAW,OAAO,KAAK,cAAc,EAAE,KAAK;AAClD,UAAM,SAAS,OAAO,KAAK,SAAS,EAAE,KAAK;AAC3C,WAAO,MAAM,EAAE,cAAc,QAAQ;AAAA,EACvC,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/esm/tests/public-api/llm-and-agents.test.js

@@ -0,0 +1,128 @@
+import { describe, expect, expectTypeOf, it } from "vitest";
+import * as Stagehand from "@browserbasehq/stagehand";
+describe("LLM and Agents public API types", () => {
+  describe("AISdkClient", () => {
+    it("is exported", () => {
+      expect(Stagehand.AISdkClient).toBeDefined();
+    });
+    it("extends LLMClient", () => {
+      expectTypeOf().toExtend();
+    });
+    it("constructor accepts model parameter", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("AVAILABLE_CUA_MODELS", () => {
+    const expectedModels = [
+      "openai/computer-use-preview",
+      "openai/computer-use-preview-2025-03-11",
+      "anthropic/claude-3-7-sonnet-latest",
+      "anthropic/claude-opus-4-5-20251101",
+      "anthropic/claude-opus-4-6",
+      "anthropic/claude-haiku-4-5-20251001",
+      "anthropic/claude-sonnet-4-20250514",
+      "anthropic/claude-sonnet-4-5-20250929",
+      "google/gemini-2.5-computer-use-preview-10-2025",
+      "google/gemini-3-flash-preview",
+      "google/gemini-3-pro-preview",
+      "microsoft/fara-7b"
+    ];
+    it("AvailableCuaModel matches the known literals", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("AgentProvider", () => {
+    it("is exported", () => {
+      expect(Stagehand.AgentProvider).toBeDefined();
+    });
+    it("has getClient method", () => {
+      expectTypeOf().toBeCallableWith(
+        "test-model"
+      );
+    });
+    it("constructor accepts logger parameter", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("AnnotatedScreenshotText", () => {
+    it("is a string literal", () => {
+      expectTypeOf().toExtend();
+    });
+  });
+  describe("ConsoleMessage", () => {
+    it("has correct public interface shape", () => {
+      expectTypeOf().toExtend();
+    });
+  });
+  describe("AgentClient", () => {
+    it("getClient returns object with expected methods", () => {
+      expectTypeOf().toExtend();
+    });
+  });
+  describe("LLMClient", () => {
+    it("has correct public interface shape", () => {
+      expectTypeOf().toExtend();
+    });
+    it("constructor parameters match expected signature", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+    it("createChatCompletion can be called with basic options", () => {
+      expectTypeOf().toBeCallableWith({
+        options: {
+          messages: [
+            {
+              role: "user",
+              content: "Hello"
+            }
+          ]
+        },
+        logger: () => {
+        }
+      });
+    });
+    it("createChatCompletion can be called with response_model", () => {
+      const mockSchema = {};
+      expectTypeOf().toBeCallableWith({
+        options: {
+          messages: [
+            {
+              role: "user",
+              content: "Extract data"
+            }
+          ],
+          response_model: {
+            name: "extracted",
+            schema: mockSchema
+          }
+        },
+        logger: () => {
+        }
+      });
+    });
+    it("createChatCompletion supports generic return type", () => {
+      expectTypeOf().toExtend();
+    });
+    it("has additional methods", () => {
+      expectTypeOf().toExtend();
+      expectTypeOf().toExtend();
+      expectTypeOf().toExtend();
+      expectTypeOf().toExtend();
+      expectTypeOf().toExtend();
+      expectTypeOf().toExtend();
+      expectTypeOf().toExtend();
+      expectTypeOf().toExtend();
+      expectTypeOf().toExtend();
+    });
+  });
+  describe("modelToAgentProviderMap", () => {
+    it("only stores valid provider types", () => {
+      expectTypeOf().toExtend();
+    });
+  });
+  describe("Response", () => {
+    it("has correct public interface shape", () => {
+      expectTypeOf().toExtend();
+    });
+  });
+});
+//# sourceMappingURL=llm-and-agents.test.js.map

package/dist/esm/tests/public-api/llm-and-agents.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../tests/public-api/llm-and-agents.test.ts"],
+  "sourcesContent": ["import { describe, expect, expectTypeOf, it } from \"vitest\";\nimport * as Stagehand from \"@browserbasehq/stagehand\";\n\ndescribe(\"LLM and Agents public API types\", () => {\n  describe(\"AISdkClient\", () => {\n    type AISdkClientInstance = InstanceType<typeof Stagehand.AISdkClient>;\n\n    it(\"is exported\", () => {\n      expect(Stagehand.AISdkClient).toBeDefined();\n    });\n\n    it(\"extends LLMClient\", () => {\n      expectTypeOf<AISdkClientInstance>().toExtend<Stagehand.LLMClient>();\n    });\n\n    it(\"constructor accepts model parameter\", () => {\n      // AISdkClient constructor takes { model: LanguageModelV2 }\n      type CtorParams = ConstructorParameters<typeof Stagehand.AISdkClient>;\n      expectTypeOf<CtorParams[\"length\"]>().toEqualTypeOf<1>();\n    });\n  });\n\n  describe(\"AVAILABLE_CUA_MODELS\", () => {\n    const expectedModels = [\n      \"openai/computer-use-preview\",\n      \"openai/computer-use-preview-2025-03-11\",\n      \"anthropic/claude-3-7-sonnet-latest\",\n      \"anthropic/claude-opus-4-5-20251101\",\n      \"anthropic/claude-opus-4-6\",\n      \"anthropic/claude-haiku-4-5-20251001\",\n      \"anthropic/claude-sonnet-4-20250514\",\n      \"anthropic/claude-sonnet-4-5-20250929\",\n      \"google/gemini-2.5-computer-use-preview-10-2025\",\n      \"google/gemini-3-flash-preview\",\n      \"google/gemini-3-pro-preview\",\n      \"microsoft/fara-7b\",\n    ] as const;\n\n    it(\"AvailableCuaModel matches the known literals\", () => {\n      expectTypeOf<Stagehand.AvailableCuaModel>().toEqualTypeOf<\n        (typeof expectedModels)[number]\n      >();\n      void expectedModels; // Mark as used to satisfy ESLint\n    });\n  });\n\n  describe(\"AgentProvider\", () => {\n    type AgentProviderInstance = InstanceType<typeof Stagehand.AgentProvider>;\n\n    it(\"is exported\", () => {\n      expect(Stagehand.AgentProvider).toBeDefined();\n    });\n\n    it(\"has getClient method\", () => {\n      expectTypeOf<AgentProviderInstance[\"getClient\"]>().toBeCallableWith(\n        \"test-model\",\n      );\n    });\n\n    it(\"constructor accepts logger parameter\", () => {\n      expectTypeOf<\n        ConstructorParameters<typeof Stagehand.AgentProvider>\n      >().toEqualTypeOf<[(message: Stagehand.LogLine) => void]>();\n    });\n  });\n\n  describe(\"AnnotatedScreenshotText\", () => {\n    type ExpectedAnnotatedScreenshotText = string;\n\n    it(\"is a string literal\", () => {\n      expectTypeOf<\n        typeof Stagehand.AnnotatedScreenshotText\n      >().toExtend<ExpectedAnnotatedScreenshotText>();\n    });\n  });\n\n  describe(\"ConsoleMessage\", () => {\n    type ExpectedShape = {\n      type: () => string;\n      text: () => string;\n      args: () => unknown[];\n      location: () => {\n        url?: string;\n        lineNumber?: number;\n        columnNumber?: number;\n      };\n      page: () => unknown;\n      timestamp: () => number | undefined;\n      raw: () => unknown;\n      toString: () => string;\n    };\n\n    type ConsoleMessageInstance = InstanceType<typeof Stagehand.ConsoleMessage>;\n\n    it(\"has correct public interface shape\", () => {\n      expectTypeOf<ConsoleMessageInstance>().toExtend<ExpectedShape>();\n    });\n  });\n\n  describe(\"AgentClient\", () => {\n    type AgentProviderInstance = InstanceType<typeof Stagehand.AgentProvider>;\n    type GetClientReturn = ReturnType<AgentProviderInstance[\"getClient\"]>;\n\n    it(\"getClient returns object with expected methods\", () => {\n      type ExpectedShape = {\n        execute: (\n          options: Stagehand.AgentExecutionOptions,\n        ) => Promise<Stagehand.AgentResult>;\n        captureScreenshot: (\n          options?: Record<string, unknown>,\n        ) => Promise<unknown>;\n        setViewport: (width: number, height: number) => void;\n        setCurrentUrl: (url: string) => void;\n        setScreenshotProvider: (provider: () => Promise<string>) => void;\n        setActionHandler: (\n          handler: (action: Stagehand.AgentAction) => Promise<void>,\n        ) => void;\n      };\n      expectTypeOf<GetClientReturn>().toExtend<ExpectedShape>();\n    });\n  });\n\n  describe(\"LLMClient\", () => {\n    type ExpectedShape = {\n      type: \"openai\" | \"anthropic\" | \"cerebras\" | \"groq\" | (string & {});\n      modelName: Stagehand.AvailableModel | (string & {});\n      hasVision: boolean;\n      clientOptions: Stagehand.ClientOptions;\n      userProvidedInstructions?: string;\n    };\n\n    type ExpectedCtorParams = [Stagehand.AvailableModel, string?];\n\n    type ExpectedBasicOptions = {\n      options: {\n        messages: Array<{\n          role: \"system\" | \"user\" | \"assistant\";\n          content: string | Array<unknown>;\n        }>;\n      };\n      logger: (message: unknown) => void;\n      retries?: number;\n    };\n\n    type ExpectedWithResponseModel = ExpectedBasicOptions & {\n      options: ExpectedBasicOptions[\"options\"] & {\n        response_model: {\n          name: string;\n          schema: Stagehand.StagehandZodSchema;\n        };\n      };\n    };\n\n    type LLMClientInstance = InstanceType<typeof Stagehand.LLMClient>;\n\n    it(\"has correct public interface shape\", () => {\n      expectTypeOf<LLMClientInstance>().toExtend<ExpectedShape>();\n    });\n\n    it(\"constructor parameters match expected signature\", () => {\n      expectTypeOf<\n        ConstructorParameters<typeof Stagehand.LLMClient>\n      >().toEqualTypeOf<ExpectedCtorParams>();\n    });\n\n    it(\"createChatCompletion can be called with basic options\", () => {\n      expectTypeOf<\n        LLMClientInstance[\"createChatCompletion\"]\n      >().toBeCallableWith({\n        options: {\n          messages: [\n            {\n              role: \"user\",\n              content: \"Hello\",\n            },\n          ],\n        },\n        logger: () => {},\n      } satisfies ExpectedBasicOptions);\n    });\n\n    it(\"createChatCompletion can be called with response_model\", () => {\n      const mockSchema = {} as Stagehand.StagehandZodSchema;\n      expectTypeOf<\n        LLMClientInstance[\"createChatCompletion\"]\n      >().toBeCallableWith({\n        options: {\n          messages: [\n            {\n              role: \"user\",\n              content: \"Extract data\",\n            },\n          ],\n          response_model: {\n            name: \"extracted\",\n            schema: mockSchema,\n          },\n        },\n        logger: () => {},\n      } satisfies ExpectedWithResponseModel);\n    });\n\n    it(\"createChatCompletion supports generic return type\", () => {\n      type Result = { custom: string };\n      type ExpectedSignature = (\n        options: Stagehand.CreateChatCompletionOptions,\n      ) => Promise<Result>;\n\n      expectTypeOf<\n        LLMClientInstance[\"createChatCompletion\"]\n      >().toExtend<ExpectedSignature>();\n    });\n\n    it(\"has additional methods\", () => {\n      // These methods exist on LLMClient but have complex signatures from the 'ai' library\n      // We verify they exist by checking they're functions\n      expectTypeOf<LLMClientInstance[\"generateText\"]>().toExtend<\n        (...args: unknown[]) => unknown\n      >();\n      expectTypeOf<LLMClientInstance[\"generateObject\"]>().toExtend<\n        (...args: unknown[]) => unknown\n      >();\n      expectTypeOf<LLMClientInstance[\"streamText\"]>().toExtend<\n        (...args: unknown[]) => unknown\n      >();\n      expectTypeOf<LLMClientInstance[\"streamObject\"]>().toExtend<\n        (...args: unknown[]) => unknown\n      >();\n      expectTypeOf<LLMClientInstance[\"generateImage\"]>().toExtend<\n        (...args: unknown[]) => unknown\n      >();\n      expectTypeOf<LLMClientInstance[\"embed\"]>().toExtend<\n        (...args: unknown[]) => unknown\n      >();\n      expectTypeOf<LLMClientInstance[\"embedMany\"]>().toExtend<\n        (...args: unknown[]) => unknown\n      >();\n      expectTypeOf<LLMClientInstance[\"transcribe\"]>().toExtend<\n        (...args: unknown[]) => unknown\n      >();\n      expectTypeOf<LLMClientInstance[\"generateSpeech\"]>().toExtend<\n        (...args: unknown[]) => unknown\n      >();\n    });\n  });\n\n  describe(\"modelToAgentProviderMap\", () => {\n    type ExpectedModelToAgentProviderMap = Record<\n      string,\n      Stagehand.AgentProviderType\n    >;\n\n    it(\"only stores valid provider types\", () => {\n      expectTypeOf<\n        typeof Stagehand.modelToAgentProviderMap\n      >().toExtend<ExpectedModelToAgentProviderMap>();\n    });\n  });\n\n  describe(\"Response\", () => {\n    type ExpectedShape = {\n      url: () => string;\n      status: () => number;\n      statusText: () => string;\n      ok: () => boolean;\n      frame: () => unknown;\n      fromServiceWorker: () => boolean;\n      securityDetails: () => Promise<unknown>;\n      serverAddr: () => Promise<unknown>;\n      headers: () => Record<string, string>;\n      allHeaders: () => Promise<Record<string, string>>;\n      headerValue: (name: string) => Promise<string | null>;\n      headerValues: (name: string) => Promise<string[]>;\n      headersArray: () => Promise<Array<{ name: string; value: string }>>;\n      body: () => Promise<Buffer>;\n      text: () => Promise<string>;\n      json: <T = unknown>() => Promise<T>;\n      finished: () => Promise<null | Error>;\n      markFinished: (error: Error | null) => void;\n      applyExtraInfo: (info: unknown) => void;\n    };\n\n    type ResponseInstance = InstanceType<typeof Stagehand.Response>;\n\n    it(\"has correct public interface shape\", () => {\n      expectTypeOf<ResponseInstance>().toExtend<ExpectedShape>();\n    });\n  });\n});\n"],
+  "mappings": "AAAA,SAAS,UAAU,QAAQ,cAAc,UAAU;AACnD,YAAY,eAAe;AAE3B,SAAS,mCAAmC,MAAM;AAChD,WAAS,eAAe,MAAM;AAG5B,OAAG,eAAe,MAAM;AACtB,aAAO,UAAU,WAAW,EAAE,YAAY;AAAA,IAC5C,CAAC;AAED,OAAG,qBAAqB,MAAM;AAC5B,mBAAkC,EAAE,SAA8B;AAAA,IACpE,CAAC;AAED,OAAG,uCAAuC,MAAM;AAG9C,mBAAmC,EAAE,cAAiB;AAAA,IACxD,CAAC;AAAA,EACH,CAAC;AAED,WAAS,wBAAwB,MAAM;AACrC,UAAM,iBAAiB;AAAA,MACrB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAEA,OAAG,gDAAgD,MAAM;AACvD,mBAA0C,EAAE,cAE1C;AAAA,IAEJ,CAAC;AAAA,EACH,CAAC;AAED,WAAS,iBAAiB,MAAM;AAG9B,OAAG,eAAe,MAAM;AACtB,aAAO,UAAU,aAAa,EAAE,YAAY;AAAA,IAC9C,CAAC;AAED,OAAG,wBAAwB,MAAM;AAC/B,mBAAiD,EAAE;AAAA,QACjD;AAAA,MACF;AAAA,IACF,CAAC;AAED,OAAG,wCAAwC,MAAM;AAC/C,mBAEE,EAAE,cAAsD;AAAA,IAC5D,CAAC;AAAA,EACH,CAAC;AAED,WAAS,2BAA2B,MAAM;AAGxC,OAAG,uBAAuB,MAAM;AAC9B,mBAEE,EAAE,SAA0C;AAAA,IAChD,CAAC;AAAA,EACH,CAAC;AAED,WAAS,kBAAkB,MAAM;AAkB/B,OAAG,sCAAsC,MAAM;AAC7C,mBAAqC,EAAE,SAAwB;AAAA,IACjE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,eAAe,MAAM;AAI5B,OAAG,kDAAkD,MAAM;AAezD,mBAA8B,EAAE,SAAwB;AAAA,IAC1D,CAAC;AAAA,EACH,CAAC;AAED,WAAS,aAAa,MAAM;AAiC1B,OAAG,sCAAsC,MAAM;AAC7C,mBAAgC,EAAE,SAAwB;AAAA,IAC5D,CAAC;AAED,OAAG,mDAAmD,MAAM;AAC1D,mBAEE,EAAE,cAAkC;AAAA,IACxC,CAAC;AAED,OAAG,yDAAyD,MAAM;AAChE,mBAEE,EAAE,iBAAiB;AAAA,QACnB,SAAS;AAAA,UACP,UAAU;AAAA,YACR;AAAA,cACE,MAAM;AAAA,cACN,SAAS;AAAA,YACX;AAAA,UACF;AAAA,QACF;AAAA,QACA,QAAQ,MAAM;AAAA,QAAC;AAAA,MACjB,CAAgC;AAAA,IAClC,CAAC;AAED,OAAG,0DAA0D,MAAM;AACjE,YAAM,aAAa,CAAC;AACpB,mBAEE,EAAE,iBAAiB;AAAA,QACnB,SAAS;AAAA,UACP,UAAU;AAAA,YACR;AAAA,cACE,MAAM;AAAA,cACN,SAAS;AAAA,YACX;AAAA,UACF;AAAA,UACA,gBAAgB;AAAA,YACd,MAAM;AAAA,YACN,QAAQ;AAAA,UACV;AAAA,QACF;AAAA,QACA,QAAQ,MAAM;AAAA,QAAC;AAAA,MACjB,CAAqC;AAAA,IACvC,CAAC;AAED,OAAG,qDAAqD,MAAM;AAM5D,mBAEE,EAAE,SAA4B;AAAA,IAClC,CAAC;AAED,OAAG,0BAA0B,MAAM;AAGjC,mBAAgD,EAAE,SAEhD;AACF,mBAAkD,EAAE,SAElD;AACF,mBAA8C,EAAE,SAE9C;AACF,mBAAgD,EAAE,SAEhD;AACF,mBAAiD,EAAE,SAEjD;AACF,mBAAyC,EAAE,SAEzC;AACF,mBAA6C,EAAE,SAE7C;AACF,mBAA8C,EAAE,SAE9C;AACF,mBAAkD,EAAE,SAElD;AAAA,IACJ,CAAC;AAAA,EACH,CAAC;AAED,WAAS,2BAA2B,MAAM;AAMxC,OAAG,oCAAoC,MAAM;AAC3C,mBAEE,EAAE,SAA0C;AAAA,IAChD,CAAC;AAAA,EACH,CAAC;AAED,WAAS,YAAY,MAAM;AAyBzB,OAAG,sCAAsC,MAAM;AAC7C,mBAA+B,EAAE,SAAwB;AAAA,IAC3D,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/esm/tests/public-api/public-error-types.test.js

@@ -0,0 +1,71 @@
+import { describe, expectTypeOf, it } from "vitest";
+import * as Stagehand from "@browserbasehq/stagehand";
+const publicErrorTypes = {
+  AgentAbortError: Stagehand.AgentAbortError,
+  AgentScreenshotProviderError: Stagehand.AgentScreenshotProviderError,
+  BrowserbaseSessionNotFoundError: Stagehand.BrowserbaseSessionNotFoundError,
+  CaptchaTimeoutError: Stagehand.CaptchaTimeoutError,
+  ConnectionTimeoutError: Stagehand.ConnectionTimeoutError,
+  ContentFrameNotFoundError: Stagehand.ContentFrameNotFoundError,
+  CreateChatCompletionResponseError: Stagehand.CreateChatCompletionResponseError,
+  CuaModelRequiredError: Stagehand.CuaModelRequiredError,
+  ElementNotVisibleError: Stagehand.ElementNotVisibleError,
+  ExperimentalApiConflictError: Stagehand.ExperimentalApiConflictError,
+  ExperimentalNotConfiguredError: Stagehand.ExperimentalNotConfiguredError,
+  HandlerNotInitializedError: Stagehand.HandlerNotInitializedError,
+  InvalidAISDKModelFormatError: Stagehand.InvalidAISDKModelFormatError,
+  LLMResponseError: Stagehand.LLMResponseError,
+  MCPConnectionError: Stagehand.MCPConnectionError,
+  MissingEnvironmentVariableError: Stagehand.MissingEnvironmentVariableError,
+  MissingLLMConfigurationError: Stagehand.MissingLLMConfigurationError,
+  PageNotFoundError: Stagehand.PageNotFoundError,
+  ResponseBodyError: Stagehand.ResponseBodyError,
+  ResponseParseError: Stagehand.ResponseParseError,
+  StagehandAPIError: Stagehand.StagehandAPIError,
+  StagehandAPIUnauthorizedError: Stagehand.StagehandAPIUnauthorizedError,
+  StagehandClickError: Stagehand.StagehandClickError,
+  StagehandClosedError: Stagehand.StagehandClosedError,
+  StagehandDefaultError: Stagehand.StagehandDefaultError,
+  StagehandDomProcessError: Stagehand.StagehandDomProcessError,
+  StagehandElementNotFoundError: Stagehand.StagehandElementNotFoundError,
+  StagehandEnvironmentError: Stagehand.StagehandEnvironmentError,
+  StagehandError: Stagehand.StagehandError,
+  StagehandEvalError: Stagehand.StagehandEvalError,
+  StagehandHttpError: Stagehand.StagehandHttpError,
+  StagehandIframeError: Stagehand.StagehandIframeError,
+  StagehandInitError: Stagehand.StagehandInitError,
+  StagehandInvalidArgumentError: Stagehand.StagehandInvalidArgumentError,
+  StagehandLocatorError: Stagehand.StagehandLocatorError,
+  StagehandMissingArgumentError: Stagehand.StagehandMissingArgumentError,
+  StagehandNotInitializedError: Stagehand.StagehandNotInitializedError,
+  StagehandResponseBodyError: Stagehand.StagehandResponseBodyError,
+  StagehandResponseParseError: Stagehand.StagehandResponseParseError,
+  StagehandServerError: Stagehand.StagehandServerError,
+  StagehandShadowRootMissingError: Stagehand.StagehandShadowRootMissingError,
+  StagehandShadowSegmentEmptyError: Stagehand.StagehandShadowSegmentEmptyError,
+  StagehandShadowSegmentNotFoundError: Stagehand.StagehandShadowSegmentNotFoundError,
+  StreamingCallbacksInNonStreamingModeError: Stagehand.StreamingCallbacksInNonStreamingModeError,
+  StagehandSnapshotError: Stagehand.StagehandSnapshotError,
+  TimeoutError: Stagehand.TimeoutError,
+  UnsupportedAISDKModelProviderError: Stagehand.UnsupportedAISDKModelProviderError,
+  UnsupportedModelError: Stagehand.UnsupportedModelError,
+  UnsupportedModelProviderError: Stagehand.UnsupportedModelProviderError,
+  XPathResolutionError: Stagehand.XPathResolutionError,
+  ZodSchemaValidationError: Stagehand.ZodSchemaValidationError,
+  ActTimeoutError: Stagehand.ActTimeoutError,
+  ObserveTimeoutError: Stagehand.ObserveTimeoutError,
+  ExtractTimeoutError: Stagehand.ExtractTimeoutError
+};
+const errorTypes = Object.keys(publicErrorTypes);
+describe("Stagehand public error types", () => {
+  describe("errors", () => {
+    it.each(errorTypes)("%s extends Error", (errorTypeName) => {
+      const ErrorClass = Stagehand[errorTypeName];
+      expectTypeOf().toExtend();
+    });
+  });
+});
+export {
+  publicErrorTypes
+};
+//# sourceMappingURL=public-error-types.test.js.map

package/dist/esm/tests/public-api/public-error-types.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../tests/public-api/public-error-types.test.ts"],
+  "sourcesContent": ["import { describe, expectTypeOf, it } from \"vitest\";\nimport * as Stagehand from \"@browserbasehq/stagehand\";\n\nexport const publicErrorTypes = {\n  AgentAbortError: Stagehand.AgentAbortError,\n  AgentScreenshotProviderError: Stagehand.AgentScreenshotProviderError,\n  BrowserbaseSessionNotFoundError: Stagehand.BrowserbaseSessionNotFoundError,\n  CaptchaTimeoutError: Stagehand.CaptchaTimeoutError,\n  ConnectionTimeoutError: Stagehand.ConnectionTimeoutError,\n  ContentFrameNotFoundError: Stagehand.ContentFrameNotFoundError,\n  CreateChatCompletionResponseError:\n    Stagehand.CreateChatCompletionResponseError,\n  CuaModelRequiredError: Stagehand.CuaModelRequiredError,\n  ElementNotVisibleError: Stagehand.ElementNotVisibleError,\n  ExperimentalApiConflictError: Stagehand.ExperimentalApiConflictError,\n  ExperimentalNotConfiguredError: Stagehand.ExperimentalNotConfiguredError,\n  HandlerNotInitializedError: Stagehand.HandlerNotInitializedError,\n  InvalidAISDKModelFormatError: Stagehand.InvalidAISDKModelFormatError,\n  LLMResponseError: Stagehand.LLMResponseError,\n  MCPConnectionError: Stagehand.MCPConnectionError,\n  MissingEnvironmentVariableError: Stagehand.MissingEnvironmentVariableError,\n  MissingLLMConfigurationError: Stagehand.MissingLLMConfigurationError,\n  PageNotFoundError: Stagehand.PageNotFoundError,\n  ResponseBodyError: Stagehand.ResponseBodyError,\n  ResponseParseError: Stagehand.ResponseParseError,\n  StagehandAPIError: Stagehand.StagehandAPIError,\n  StagehandAPIUnauthorizedError: Stagehand.StagehandAPIUnauthorizedError,\n  StagehandClickError: Stagehand.StagehandClickError,\n  StagehandClosedError: Stagehand.StagehandClosedError,\n  StagehandDefaultError: Stagehand.StagehandDefaultError,\n  StagehandDomProcessError: Stagehand.StagehandDomProcessError,\n  StagehandElementNotFoundError: Stagehand.StagehandElementNotFoundError,\n  StagehandEnvironmentError: Stagehand.StagehandEnvironmentError,\n  StagehandError: Stagehand.StagehandError,\n  StagehandEvalError: Stagehand.StagehandEvalError,\n  StagehandHttpError: Stagehand.StagehandHttpError,\n  StagehandIframeError: Stagehand.StagehandIframeError,\n  StagehandInitError: Stagehand.StagehandInitError,\n  StagehandInvalidArgumentError: Stagehand.StagehandInvalidArgumentError,\n  StagehandLocatorError: Stagehand.StagehandLocatorError,\n  StagehandMissingArgumentError: Stagehand.StagehandMissingArgumentError,\n  StagehandNotInitializedError: Stagehand.StagehandNotInitializedError,\n  StagehandResponseBodyError: Stagehand.StagehandResponseBodyError,\n  StagehandResponseParseError: Stagehand.StagehandResponseParseError,\n  StagehandServerError: Stagehand.StagehandServerError,\n  StagehandShadowRootMissingError: Stagehand.StagehandShadowRootMissingError,\n  StagehandShadowSegmentEmptyError: Stagehand.StagehandShadowSegmentEmptyError,\n  StagehandShadowSegmentNotFoundError:\n    Stagehand.StagehandShadowSegmentNotFoundError,\n  StreamingCallbacksInNonStreamingModeError:\n    Stagehand.StreamingCallbacksInNonStreamingModeError,\n  StagehandSnapshotError: Stagehand.StagehandSnapshotError,\n  TimeoutError: Stagehand.TimeoutError,\n  UnsupportedAISDKModelProviderError:\n    Stagehand.UnsupportedAISDKModelProviderError,\n  UnsupportedModelError: Stagehand.UnsupportedModelError,\n  UnsupportedModelProviderError: Stagehand.UnsupportedModelProviderError,\n  XPathResolutionError: Stagehand.XPathResolutionError,\n  ZodSchemaValidationError: Stagehand.ZodSchemaValidationError,\n  ActTimeoutError: Stagehand.ActTimeoutError,\n  ObserveTimeoutError: Stagehand.ObserveTimeoutError,\n  ExtractTimeoutError: Stagehand.ExtractTimeoutError,\n} as const;\n\nconst errorTypes = Object.keys(publicErrorTypes) as Array<\n  keyof typeof publicErrorTypes\n>;\n\ndescribe(\"Stagehand public error types\", () => {\n  describe(\"errors\", () => {\n    it.each(errorTypes)(\"%s extends Error\", (errorTypeName) => {\n      const ErrorClass = Stagehand[errorTypeName];\n      type ErrorClassType = typeof ErrorClass;\n      expectTypeOf<InstanceType<ErrorClassType>>().toExtend<Error>();\n      void ErrorClass; // Mark as used to satisfy ESLint\n    });\n  });\n});\n"],
+  "mappings": "AAAA,SAAS,UAAU,cAAc,UAAU;AAC3C,YAAY,eAAe;AAEpB,MAAM,mBAAmB;AAAA,EAC9B,iBAAiB,UAAU;AAAA,EAC3B,8BAA8B,UAAU;AAAA,EACxC,iCAAiC,UAAU;AAAA,EAC3C,qBAAqB,UAAU;AAAA,EAC/B,wBAAwB,UAAU;AAAA,EAClC,2BAA2B,UAAU;AAAA,EACrC,mCACE,UAAU;AAAA,EACZ,uBAAuB,UAAU;AAAA,EACjC,wBAAwB,UAAU;AAAA,EAClC,8BAA8B,UAAU;AAAA,EACxC,gCAAgC,UAAU;AAAA,EAC1C,4BAA4B,UAAU;AAAA,EACtC,8BAA8B,UAAU;AAAA,EACxC,kBAAkB,UAAU;AAAA,EAC5B,oBAAoB,UAAU;AAAA,EAC9B,iCAAiC,UAAU;AAAA,EAC3C,8BAA8B,UAAU;AAAA,EACxC,mBAAmB,UAAU;AAAA,EAC7B,mBAAmB,UAAU;AAAA,EAC7B,oBAAoB,UAAU;AAAA,EAC9B,mBAAmB,UAAU;AAAA,EAC7B,+BAA+B,UAAU;AAAA,EACzC,qBAAqB,UAAU;AAAA,EAC/B,sBAAsB,UAAU;AAAA,EAChC,uBAAuB,UAAU;AAAA,EACjC,0BAA0B,UAAU;AAAA,EACpC,+BAA+B,UAAU;AAAA,EACzC,2BAA2B,UAAU;AAAA,EACrC,gBAAgB,UAAU;AAAA,EAC1B,oBAAoB,UAAU;AAAA,EAC9B,oBAAoB,UAAU;AAAA,EAC9B,sBAAsB,UAAU;AAAA,EAChC,oBAAoB,UAAU;AAAA,EAC9B,+BAA+B,UAAU;AAAA,EACzC,uBAAuB,UAAU;AAAA,EACjC,+BAA+B,UAAU;AAAA,EACzC,8BAA8B,UAAU;AAAA,EACxC,4BAA4B,UAAU;AAAA,EACtC,6BAA6B,UAAU;AAAA,EACvC,sBAAsB,UAAU;AAAA,EAChC,iCAAiC,UAAU;AAAA,EAC3C,kCAAkC,UAAU;AAAA,EAC5C,qCACE,UAAU;AAAA,EACZ,2CACE,UAAU;AAAA,EACZ,wBAAwB,UAAU;AAAA,EAClC,cAAc,UAAU;AAAA,EACxB,oCACE,UAAU;AAAA,EACZ,uBAAuB,UAAU;AAAA,EACjC,+BAA+B,UAAU;AAAA,EACzC,sBAAsB,UAAU;AAAA,EAChC,0BAA0B,UAAU;AAAA,EACpC,iBAAiB,UAAU;AAAA,EAC3B,qBAAqB,UAAU;AAAA,EAC/B,qBAAqB,UAAU;AACjC;AAEA,MAAM,aAAa,OAAO,KAAK,gBAAgB;AAI/C,SAAS,gCAAgC,MAAM;AAC7C,WAAS,UAAU,MAAM;AACvB,OAAG,KAAK,UAAU,EAAE,oBAAoB,CAAC,kBAAkB;AACzD,YAAM,aAAa,UAAU,aAAa;AAE1C,mBAA2C,EAAE,SAAgB;AAAA,IAE/D,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/esm/tests/public-api/public-types.test.js

@@ -0,0 +1,74 @@
+import { describe, expectTypeOf, it } from "vitest";
+describe("Stagehand public API types", () => {
+  describe("AnyPage", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("ActOptions", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("ActResult", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("ExtractOptions", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("ObserveOptions", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("Action", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("AgentAction", () => {
+    it("has type field", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("AgentExecuteOptions", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("AgentStreamExecuteOptions", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("AgentExecutionOptions", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("AgentResult", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("AgentConfig", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toExtend();
+    });
+  });
+  describe("AgentToolMode", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("HistoryEntry", () => {
+    it("matches expected type shape", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+});
+//# sourceMappingURL=public-types.test.js.map

package/dist/esm/tests/public-api/public-types.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../tests/public-api/public-types.test.ts"],
+  "sourcesContent": ["import { describe, expectTypeOf, it } from \"vitest\";\nimport * as Stagehand from \"@browserbasehq/stagehand\";\n\n// Type-level manifest of all expected exported types\n// Since these types don't exist at runtime, we currently need to manually add new publicly exported types\n// to this list ourselves - it's not automatically going to catch changes like our export-surface.test.ts does.\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ntype ExpectedExportedTypes = {\n  // Types from model.ts\n  AvailableModel: Stagehand.AvailableModel;\n  AvailableCuaModel: Stagehand.AvailableCuaModel;\n  ModelProvider: Stagehand.ModelProvider;\n  ClientOptions: Stagehand.ClientOptions;\n  ModelConfiguration: Stagehand.ModelConfiguration;\n  AnthropicJsonSchemaObject: Stagehand.AnthropicJsonSchemaObject;\n  AISDKProvider: Stagehand.AISDKProvider;\n  AISDKCustomProvider: Stagehand.AISDKCustomProvider;\n  LLMTool: Stagehand.LLMTool;\n  // Types from methods.ts\n  ActOptions: Stagehand.ActOptions;\n  ActResult: Stagehand.ActResult;\n  ExtractResult: Stagehand.ExtractResult<Stagehand.StagehandZodSchema>;\n  Action: Stagehand.Action;\n  HistoryEntry: Stagehand.HistoryEntry;\n  ExtractOptions: Stagehand.ExtractOptions;\n  ObserveOptions: Stagehand.ObserveOptions;\n  V3FunctionName: Stagehand.V3FunctionName;\n  // Types from agent.ts\n  Tool: Stagehand.Tool;\n  AgentAction: Stagehand.AgentAction;\n  AgentResult: Stagehand.AgentResult;\n  AgentExecuteOptions: Stagehand.AgentExecuteOptions;\n  AgentType: Stagehand.AgentType;\n  AgentExecutionOptions: Stagehand.AgentExecutionOptions<Stagehand.AgentExecuteOptions>;\n  AgentHandlerOptions: Stagehand.AgentHandlerOptions;\n  ActionExecutionResult: Stagehand.ActionExecutionResult;\n  ToolUseItem: Stagehand.ToolUseItem;\n  AnthropicMessage: Stagehand.AnthropicMessage;\n  AnthropicContentBlock: Stagehand.AnthropicContentBlock;\n  AnthropicTextBlock: Stagehand.AnthropicTextBlock;\n  AnthropicToolResult: Stagehand.AnthropicToolResult;\n  ResponseItem: Stagehand.ResponseItem;\n  ComputerCallItem: Stagehand.ComputerCallItem;\n  FunctionCallItem: Stagehand.FunctionCallItem;\n  ResponseInputItem: Stagehand.ResponseInputItem;\n  AgentInstance: Stagehand.AgentInstance;\n  AgentProviderType: Stagehand.AgentProviderType;\n  AgentModelConfig: Stagehand.AgentModelConfig;\n  AgentConfig: Stagehand.AgentConfig;\n  AgentToolMode: Stagehand.AgentToolMode;\n  AgentCallbacks: Stagehand.AgentCallbacks;\n  AgentExecuteCallbacks: Stagehand.AgentExecuteCallbacks;\n  AgentStreamCallbacks: Stagehand.AgentStreamCallbacks;\n  AgentExecuteOptionsBase: Stagehand.AgentExecuteOptionsBase;\n  AgentStreamExecuteOptions: Stagehand.AgentStreamExecuteOptions;\n  ModelMessage: Stagehand.ModelMessage;\n  // Types from agent/tools\n  AgentTools: Stagehand.AgentTools;\n  AgentToolTypesMap: Stagehand.AgentToolTypesMap;\n  AgentUITools: Stagehand.AgentUITools;\n  AgentToolCall: Stagehand.AgentToolCall;\n  AgentToolResult: Stagehand.AgentToolResult;\n  // Types from logs.ts\n  LogLevel: Stagehand.LogLevel;\n  LogLine: Stagehand.LogLine;\n  Logger: Stagehand.Logger;\n  // Types from metrics.ts\n  StagehandMetrics: Stagehand.StagehandMetrics;\n  // Types from options.ts\n  V3Env: Stagehand.V3Env;\n  LocalBrowserLaunchOptions: Stagehand.LocalBrowserLaunchOptions;\n  V3Options: Stagehand.V3Options;\n  // Types from page.ts\n  AnyPage: Stagehand.AnyPage;\n  Page: Stagehand.Page;\n  PlaywrightPage: Stagehand.PlaywrightPage;\n  PatchrightPage: Stagehand.PatchrightPage;\n  PuppeteerPage: Stagehand.PuppeteerPage;\n  ConsoleListener: Stagehand.ConsoleListener;\n  LoadState: Stagehand.LoadState;\n  // Types from LLMClient.ts\n  ChatMessage: Stagehand.ChatMessage;\n  ChatMessageContent: Stagehand.ChatMessageContent;\n  ChatMessageImageContent: Stagehand.ChatMessageImageContent;\n  ChatMessageTextContent: Stagehand.ChatMessageTextContent;\n  ChatCompletionOptions: Stagehand.ChatCompletionOptions;\n  LLMResponse: Stagehand.LLMResponse;\n  CreateChatCompletionOptions: Stagehand.CreateChatCompletionOptions;\n  LLMUsage: Stagehand.LLMUsage;\n  LLMParsedResponse: Stagehand.LLMParsedResponse<Record<string, unknown>>;\n  // Types from zodCompat.ts\n  StagehandZodSchema: Stagehand.StagehandZodSchema;\n  StagehandZodObject: Stagehand.StagehandZodObject;\n  InferStagehandSchema: Stagehand.InferStagehandSchema<Stagehand.StagehandZodSchema>;\n  JsonSchemaDocument: Stagehand.JsonSchemaDocument;\n  // Types from utils.ts\n  JsonSchema: Stagehand.JsonSchema;\n  JsonSchemaProperty: Stagehand.JsonSchemaProperty;\n};\n\ndescribe(\"Stagehand public API types\", () => {\n  describe(\"AnyPage\", () => {\n    type ExpectedAnyPage =\n      | Stagehand.PlaywrightPage\n      | Stagehand.PuppeteerPage\n      | Stagehand.PatchrightPage\n      | Stagehand.Page;\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.AnyPage>().toEqualTypeOf<ExpectedAnyPage>();\n    });\n  });\n\n  describe(\"ActOptions\", () => {\n    type ExpectedActOptions = {\n      model?: Stagehand.ModelConfiguration;\n      variables?: Record<string, string>;\n      timeout?: number;\n      page?: Stagehand.AnyPage;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.ActOptions>().toEqualTypeOf<ExpectedActOptions>();\n    });\n  });\n\n  describe(\"ActResult\", () => {\n    type ExpectedActResult = {\n      success: boolean;\n      message: string;\n      actionDescription: string;\n      actions: Stagehand.Action[];\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.ActResult>().toEqualTypeOf<ExpectedActResult>();\n    });\n  });\n\n  describe(\"ExtractOptions\", () => {\n    type ExpectedExtractOptions = {\n      model?: Stagehand.ModelConfiguration;\n      timeout?: number;\n      selector?: string;\n      page?: Stagehand.AnyPage;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.ExtractOptions>().toEqualTypeOf<ExpectedExtractOptions>();\n    });\n  });\n\n  describe(\"ObserveOptions\", () => {\n    type ExpectedObserveOptions = {\n      model?: Stagehand.ModelConfiguration;\n      timeout?: number;\n      selector?: string;\n      page?: Stagehand.AnyPage;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.ObserveOptions>().toEqualTypeOf<ExpectedObserveOptions>();\n    });\n  });\n\n  describe(\"Action\", () => {\n    type ExpectedAction = {\n      selector: string;\n      description: string;\n      method?: string;\n      arguments?: string[];\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.Action>().toEqualTypeOf<ExpectedAction>();\n    });\n  });\n\n  describe(\"AgentAction\", () => {\n    // AgentAction is a separate type from Action, not an extension\n    // It has additional fields like type, reasoning, taskCompleted, etc.\n    it(\"has type field\", () => {\n      type TestAction = { type: string } & Stagehand.AgentAction;\n      expectTypeOf<TestAction[\"type\"]>().toEqualTypeOf<string>();\n    });\n  });\n\n  describe(\"AgentExecuteOptions\", () => {\n    type ExpectedAgentExecuteOptions = {\n      instruction: string;\n      maxSteps?: number;\n      page?: Stagehand.AnyPage;\n      highlightCursor?: boolean;\n      messages?: Stagehand.ModelMessage[];\n      signal?: AbortSignal;\n      excludeTools?: string[];\n      output?: Stagehand.StagehandZodObject;\n      callbacks?: Stagehand.AgentExecuteCallbacks;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.AgentExecuteOptions>().toEqualTypeOf<ExpectedAgentExecuteOptions>();\n    });\n  });\n\n  describe(\"AgentStreamExecuteOptions\", () => {\n    type ExpectedAgentStreamExecuteOptions = {\n      instruction: string;\n      maxSteps?: number;\n      page?: Stagehand.AnyPage;\n      highlightCursor?: boolean;\n      messages?: Stagehand.ModelMessage[];\n      signal?: AbortSignal;\n      excludeTools?: string[];\n      output?: Stagehand.StagehandZodObject;\n      callbacks?: Stagehand.AgentStreamCallbacks;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.AgentStreamExecuteOptions>().toEqualTypeOf<ExpectedAgentStreamExecuteOptions>();\n    });\n  });\n\n  describe(\"AgentExecutionOptions\", () => {\n    type ExpectedAgentExecutionOptions<T = Stagehand.AgentExecuteOptions> = {\n      options: T;\n      logger: (message: Stagehand.LogLine) => void;\n      retries?: number;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<\n        Stagehand.AgentExecutionOptions<Stagehand.AgentExecuteOptions>\n      >().toEqualTypeOf<\n        ExpectedAgentExecutionOptions<Stagehand.AgentExecuteOptions>\n      >();\n    });\n  });\n\n  describe(\"AgentResult\", () => {\n    type ExpectedAgentResult = {\n      success: boolean;\n      message: string;\n      actions: Stagehand.AgentAction[];\n      completed: boolean;\n      metadata?: Record<string, unknown>;\n      usage?: {\n        input_tokens: number;\n        output_tokens: number;\n        reasoning_tokens?: number;\n        cached_input_tokens?: number;\n        inference_time_ms: number;\n      };\n      messages?: Stagehand.ModelMessage[];\n      output?: Record<string, unknown>;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.AgentResult>().toEqualTypeOf<ExpectedAgentResult>();\n    });\n  });\n\n  describe(\"AgentConfig\", () => {\n    type ExpectedAgentConfig = {\n      systemPrompt?: string;\n      integrations?: (unknown | string)[];\n      tools?: unknown;\n      cua?: boolean;\n      model?: string | Stagehand.AgentModelConfig<string>;\n      executionModel?: string | Stagehand.AgentModelConfig<string>;\n      stream?: boolean;\n      mode?: Stagehand.AgentToolMode;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.AgentConfig>().toExtend<ExpectedAgentConfig>();\n    });\n  });\n\n  describe(\"AgentToolMode\", () => {\n    type ExpectedAgentToolMode = \"dom\" | \"hybrid\" | \"cua\";\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.AgentToolMode>().toEqualTypeOf<ExpectedAgentToolMode>();\n    });\n  });\n\n  describe(\"HistoryEntry\", () => {\n    type ExpectedHistoryEntry = {\n      method: \"act\" | \"extract\" | \"observe\" | \"navigate\" | \"agent\";\n      parameters: unknown;\n      result: unknown;\n      timestamp: string;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.HistoryEntry>().toEqualTypeOf<ExpectedHistoryEntry>();\n    });\n  });\n});\n"],
+  "mappings": "AAAA,SAAS,UAAU,cAAc,UAAU;AAqG3C,SAAS,8BAA8B,MAAM;AAC3C,WAAS,WAAW,MAAM;AAOxB,OAAG,+BAA+B,MAAM;AACtC,mBAAgC,EAAE,cAA+B;AAAA,IACnE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,cAAc,MAAM;AAQ3B,OAAG,+BAA+B,MAAM;AACtC,mBAAmC,EAAE,cAAkC;AAAA,IACzE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,aAAa,MAAM;AAQ1B,OAAG,+BAA+B,MAAM;AACtC,mBAAkC,EAAE,cAAiC;AAAA,IACvE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,kBAAkB,MAAM;AAQ/B,OAAG,+BAA+B,MAAM;AACtC,mBAAuC,EAAE,cAAsC;AAAA,IACjF,CAAC;AAAA,EACH,CAAC;AAED,WAAS,kBAAkB,MAAM;AAQ/B,OAAG,+BAA+B,MAAM;AACtC,mBAAuC,EAAE,cAAsC;AAAA,IACjF,CAAC;AAAA,EACH,CAAC;AAED,WAAS,UAAU,MAAM;AAQvB,OAAG,+BAA+B,MAAM;AACtC,mBAA+B,EAAE,cAA8B;AAAA,IACjE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,eAAe,MAAM;AAG5B,OAAG,kBAAkB,MAAM;AAEzB,mBAAiC,EAAE,cAAsB;AAAA,IAC3D,CAAC;AAAA,EACH,CAAC;AAED,WAAS,uBAAuB,MAAM;AAapC,OAAG,+BAA+B,MAAM;AACtC,mBAA4C,EAAE,cAA2C;AAAA,IAC3F,CAAC;AAAA,EACH,CAAC;AAED,WAAS,6BAA6B,MAAM;AAa1C,OAAG,+BAA+B,MAAM;AACtC,mBAAkD,EAAE,cAAiD;AAAA,IACvG,CAAC;AAAA,EACH,CAAC;AAED,WAAS,yBAAyB,MAAM;AAOtC,OAAG,+BAA+B,MAAM;AACtC,mBAEE,EAAE,cAEF;AAAA,IACJ,CAAC;AAAA,EACH,CAAC;AAED,WAAS,eAAe,MAAM;AAkB5B,OAAG,+BAA+B,MAAM;AACtC,mBAAoC,EAAE,cAAmC;AAAA,IAC3E,CAAC;AAAA,EACH,CAAC;AAED,WAAS,eAAe,MAAM;AAY5B,OAAG,+BAA+B,MAAM;AACtC,mBAAoC,EAAE,SAA8B;AAAA,IACtE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,iBAAiB,MAAM;AAG9B,OAAG,+BAA+B,MAAM;AACtC,mBAAsC,EAAE,cAAqC;AAAA,IAC/E,CAAC;AAAA,EACH,CAAC;AAED,WAAS,gBAAgB,MAAM;AAQ7B,OAAG,+BAA+B,MAAM;AACtC,mBAAqC,EAAE,cAAoC;AAAA,IAC7E,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/esm/tests/public-api/runtime-utils.test.js

@@ -0,0 +1,31 @@
+import { describe, expectTypeOf, it } from "vitest";
+import * as Stagehand from "@browserbasehq/stagehand";
+describe("Runtime Utils public API types", () => {
+  describe("injectUrls", () => {
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.injectUrls
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  describe("isRunningInBun", () => {
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.isRunningInBun
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  describe("loadApiKeyFromEnv", () => {
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.loadApiKeyFromEnv
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  describe("providerEnvVarMap", () => {
+    it("maps providers to environment variable names", () => {
+      expectTypeOf().toExtend();
+    });
+  });
+});
+//# sourceMappingURL=runtime-utils.test.js.map

package/dist/esm/tests/public-api/runtime-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../tests/public-api/runtime-utils.test.ts"],
+  "sourcesContent": ["import { describe, expectTypeOf, it } from \"vitest\";\nimport * as Stagehand from \"@browserbasehq/stagehand\";\n\ndescribe(\"Runtime Utils public API types\", () => {\n  describe(\"injectUrls\", () => {\n    type ExpectedInjectUrlsParams = [\n      unknown,\n      Array<string | number>,\n      Record<string, string>,\n    ];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.injectUrls,\n      ).parameters.branded.toEqualTypeOf<ExpectedInjectUrlsParams>();\n    });\n  });\n\n  describe(\"isRunningInBun\", () => {\n    type ExpectedIsRunningInBunParams = [];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.isRunningInBun,\n      ).parameters.branded.toEqualTypeOf<ExpectedIsRunningInBunParams>();\n    });\n  });\n\n  describe(\"loadApiKeyFromEnv\", () => {\n    type ExpectedLoadApiKeyFromEnvParams = [\n      string | undefined,\n      (logLine: Stagehand.LogLine) => void,\n    ];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.loadApiKeyFromEnv,\n      ).parameters.branded.toEqualTypeOf<ExpectedLoadApiKeyFromEnvParams>();\n    });\n  });\n\n  describe(\"providerEnvVarMap\", () => {\n    type ExpectedProviderEnvVarMap = Partial<\n      Record<string, string | Array<string>>\n    >;\n\n    it(\"maps providers to environment variable names\", () => {\n      expectTypeOf<\n        typeof Stagehand.providerEnvVarMap\n      >().toExtend<ExpectedProviderEnvVarMap>();\n    });\n  });\n});\n"],
+  "mappings": "AAAA,SAAS,UAAU,cAAc,UAAU;AAC3C,YAAY,eAAe;AAE3B,SAAS,kCAAkC,MAAM;AAC/C,WAAS,cAAc,MAAM;AAO3B,OAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAAwC;AAAA,IAC/D,CAAC;AAAA,EACH,CAAC;AAED,WAAS,kBAAkB,MAAM;AAG/B,OAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA4C;AAAA,IACnE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,qBAAqB,MAAM;AAMlC,OAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA+C;AAAA,IACtE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,qBAAqB,MAAM;AAKlC,OAAG,gDAAgD,MAAM;AACvD,mBAEE,EAAE,SAAoC;AAAA,IAC1C,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/esm/tests/public-api/schema-utils.test.js

@@ -0,0 +1,78 @@
+import { describe, expectTypeOf, it } from "vitest";
+import * as Stagehand from "@browserbasehq/stagehand";
+describe("Schema Utils public API types", () => {
+  describe("defaultExtractSchema", () => {
+    it("infers to the correct type", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("getZodType", () => {
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.getZodType
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  describe("isZod3Schema", () => {
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.isZod3Schema
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  describe("isZod4Schema", () => {
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.isZod4Schema
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  describe("jsonSchemaToZod", () => {
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.jsonSchemaToZod
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  describe("pageTextSchema", () => {
+    it("infers to the correct type", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("toGeminiSchema", () => {
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.toGeminiSchema
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  describe("toJsonSchema", () => {
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.toJsonSchema
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  describe("transformSchema", () => {
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.transformSchema
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  describe("trimTrailingTextNode", () => {
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.trimTrailingTextNode
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  describe("validateZodSchema", () => {
+    it("has correct parameter types", () => {
+      expectTypeOf(
+        Stagehand.validateZodSchema
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+});
+//# sourceMappingURL=schema-utils.test.js.map

package/dist/esm/tests/public-api/schema-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../tests/public-api/schema-utils.test.ts"],
+  "sourcesContent": ["import { describe, expectTypeOf, it } from \"vitest\";\nimport * as Stagehand from \"@browserbasehq/stagehand\";\n\ndescribe(\"Schema Utils public API types\", () => {\n  describe(\"defaultExtractSchema\", () => {\n    type ExpectedInferredType = { extraction: string };\n\n    it(\"infers to the correct type\", () => {\n      expectTypeOf<\n        Stagehand.InferStagehandSchema<typeof Stagehand.defaultExtractSchema>\n      >().toEqualTypeOf<ExpectedInferredType>();\n    });\n  });\n\n  describe(\"getZodType\", () => {\n    type ExpectedGetZodTypeParams = [Stagehand.StagehandZodSchema];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.getZodType,\n      ).parameters.branded.toEqualTypeOf<ExpectedGetZodTypeParams>();\n    });\n  });\n\n  describe(\"isZod3Schema\", () => {\n    type ExpectedIsZod3SchemaParams = [Stagehand.StagehandZodSchema];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.isZod3Schema,\n      ).parameters.branded.toEqualTypeOf<ExpectedIsZod3SchemaParams>();\n    });\n  });\n\n  describe(\"isZod4Schema\", () => {\n    type ExpectedIsZod4SchemaParams = [Stagehand.StagehandZodSchema];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.isZod4Schema,\n      ).parameters.branded.toEqualTypeOf<ExpectedIsZod4SchemaParams>();\n    });\n  });\n\n  describe(\"jsonSchemaToZod\", () => {\n    type ExpectedJsonSchemaToZodParams = [Stagehand.JsonSchema];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.jsonSchemaToZod,\n      ).parameters.branded.toEqualTypeOf<ExpectedJsonSchemaToZodParams>();\n    });\n  });\n\n  describe(\"pageTextSchema\", () => {\n    type ExpectedInferredType = { pageText: string };\n\n    it(\"infers to the correct type\", () => {\n      expectTypeOf<\n        Stagehand.InferStagehandSchema<typeof Stagehand.pageTextSchema>\n      >().toEqualTypeOf<ExpectedInferredType>();\n    });\n  });\n\n  describe(\"toGeminiSchema\", () => {\n    type ExpectedToGeminiSchemaParams = [Stagehand.StagehandZodSchema];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.toGeminiSchema,\n      ).parameters.branded.toEqualTypeOf<ExpectedToGeminiSchemaParams>();\n    });\n  });\n\n  describe(\"toJsonSchema\", () => {\n    type ExpectedToJsonSchemaParams = [Stagehand.StagehandZodSchema];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.toJsonSchema,\n      ).parameters.branded.toEqualTypeOf<ExpectedToJsonSchemaParams>();\n    });\n  });\n\n  describe(\"transformSchema\", () => {\n    type ExpectedTransformSchemaParams = [\n      Stagehand.StagehandZodSchema,\n      Array<string | number>,\n    ];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.transformSchema,\n      ).parameters.branded.toEqualTypeOf<ExpectedTransformSchemaParams>();\n    });\n  });\n\n  describe(\"trimTrailingTextNode\", () => {\n    type ExpectedTrimTrailingTextNodeParams = [string | undefined];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.trimTrailingTextNode,\n      ).parameters.branded.toEqualTypeOf<ExpectedTrimTrailingTextNodeParams>();\n    });\n  });\n\n  describe(\"validateZodSchema\", () => {\n    type ExpectedValidateZodSchemaParams = [\n      Stagehand.StagehandZodSchema,\n      unknown,\n    ];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.validateZodSchema,\n      ).parameters.branded.toEqualTypeOf<ExpectedValidateZodSchemaParams>();\n    });\n  });\n});\n"],
+  "mappings": "AAAA,SAAS,UAAU,cAAc,UAAU;AAC3C,YAAY,eAAe;AAE3B,SAAS,iCAAiC,MAAM;AAC9C,WAAS,wBAAwB,MAAM;AAGrC,OAAG,8BAA8B,MAAM;AACrC,mBAEE,EAAE,cAAoC;AAAA,IAC1C,CAAC;AAAA,EACH,CAAC;AAED,WAAS,cAAc,MAAM;AAG3B,OAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAAwC;AAAA,IAC/D,CAAC;AAAA,EACH,CAAC;AAED,WAAS,gBAAgB,MAAM;AAG7B,OAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA0C;AAAA,IACjE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,gBAAgB,MAAM;AAG7B,OAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA0C;AAAA,IACjE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,mBAAmB,MAAM;AAGhC,OAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA6C;AAAA,IACpE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,kBAAkB,MAAM;AAG/B,OAAG,8BAA8B,MAAM;AACrC,mBAEE,EAAE,cAAoC;AAAA,IAC1C,CAAC;AAAA,EACH,CAAC;AAED,WAAS,kBAAkB,MAAM;AAG/B,OAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA4C;AAAA,IACnE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,gBAAgB,MAAM;AAG7B,OAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA0C;AAAA,IACjE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,mBAAmB,MAAM;AAMhC,OAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA6C;AAAA,IACpE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,wBAAwB,MAAM;AAGrC,OAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAAkD;AAAA,IACzE,CAAC;AAAA,EACH,CAAC;AAED,WAAS,qBAAqB,MAAM;AAMlC,OAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA+C;AAAA,IACtE,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
+  "names": []
+}