@browserbasehq/orca 3.0.0-preview.1 → 3.0.0-preview.3

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

@@ -1,23 +0,0 @@
-import { z } from "zod/v3";
-import { Stagehand } from "../../index";
-export declare const createScrollTool: (stagehand: Stagehand) => import("ai/dist").Tool<z.ZodObject<{
-    pixels: z.ZodNumber;
-    direction: z.ZodEnum<["up", "down"]>;
-}, "strip", z.ZodTypeAny, {
-    direction?: "down" | "up";
-    pixels?: number;
-}, {
-    direction?: "down" | "up";
-    pixels?: number;
-}>, {
-    success: boolean;
-    pixels: number;
-}> & {
-    execute: (args: {
-        direction?: "down" | "up";
-        pixels?: number;
-    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
-        success: boolean;
-        pixels: number;
-    }>;
-};

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

@@ -1,18 +0,0 @@
-import { z } from "zod/v3";
-export declare const createWaitTool: () => import("ai/dist").Tool<z.ZodObject<{
-    timeMs: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    timeMs?: number;
-}, {
-    timeMs?: number;
-}>, {
-    success: boolean;
-    waited: number;
-}> & {
-    execute: (args: {
-        timeMs?: number;
-    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
-        success: boolean;
-        waited: number;
-    }>;
-};

package/dist/lib/agent/utils/cuaKeyMapping.d.ts

@@ -1,10 +0,0 @@
-/**
- * Universal key mapping utility for converting various key representations
- * to Playwright-compatible key names. Used by all CUA clients and handlers.
- */
-/**
- * Maps a key name from various formats to Playwright-compatible format
- * @param key The key name in any supported format
- * @returns The Playwright-compatible key name
- */
-export declare function mapKeyToPlaywright(key: string): string;

package/dist/lib/agent/utils/imageCompression.d.ts

@@ -1,53 +0,0 @@
-import { AnthropicMessage, AnthropicToolResult, ResponseInputItem as OpenAIResponseInputItem } from "@/types/agent";
-import type { Content as GoogleContent } from "@google/genai";
-export type ResponseInputItem = AnthropicMessage | AnthropicToolResult;
-export type AnthropicResponseInputItem = AnthropicMessage | AnthropicToolResult;
-export type SupportedInputItem = AnthropicResponseInputItem | OpenAIResponseInputItem | GoogleContent;
-/**
- * Finds all items in the conversation history that contain images
- * @param items - Array of conversation items to check
- * @returns Array of indices where images were found
- */
-export declare function findItemsWithImages(items: ResponseInputItem[]): number[];
-/**
- * Compresses conversation history by removing images from older items
- * while keeping the most recent images intact
- * @param items - Array of conversation items to process
- * @param keepMostRecentCount - Number of most recent image-containing items to preserve (default: 2)
- * @returns Object with processed items
- */
-export declare function compressConversationImages(items: ResponseInputItem[], keepMostRecentCount?: number): {
-    items: ResponseInputItem[];
-};
-/**
- * Finds all items in the conversation history that contain images (Google format)
- * @param items - Array of conversation items to check
- * @returns Array of indices where images were found
- */
-export declare function findGoogleItemsWithImages(items: GoogleContent[]): number[];
-/**
- * Finds all items in the conversation history that contain images (OpenAI format)
- * @param items - Array of conversation items to check
- * @returns Array of indices where images were found
- */
-export declare function findOpenAIItemsWithImages(items: OpenAIResponseInputItem[]): number[];
-/**
- * Compresses OpenAI conversation history by removing images from older items
- * while keeping the most recent images intact
- * @param items - Array of conversation items to process
- * @param keepMostRecentCount - Number of most recent image-containing items to preserve (default: 2)
- * @returns Object with processed items
- */
-export declare function compressOpenAIConversationImages(items: OpenAIResponseInputItem[], keepMostRecentCount?: number): {
-    items: OpenAIResponseInputItem[];
-};
-/**
- * Compresses Google conversation history by removing images from older items
- * while keeping the most recent images intact
- * @param items - Array of conversation items to process
- * @param keepMostRecentCount - Number of most recent image-containing items to preserve (default: 2)
- * @returns Object with processed items
- */
-export declare function compressGoogleConversationImages(items: GoogleContent[], keepMostRecentCount?: number): {
-    items: GoogleContent[];
-};

package/dist/lib/agent/utils/messageProcessing.d.ts

@@ -1,13 +0,0 @@
-import { type LanguageModelV1CallOptions } from "ai";
-export interface CompressionStats {
-    originalSize: number;
-    compressedSize: number;
-    savedChars: number;
-    compressionRatio: number;
-    screenshotCount: number;
-    ariaTreeCount: number;
-}
-export declare function processMessages(params: LanguageModelV1CallOptions): {
-    processedPrompt: LanguageModelV1CallOptions["prompt"];
-    stats: CompressionStats;
-};

package/dist/lib/api.d.ts

@@ -1,23 +0,0 @@
-import { z } from "zod/v3";
-import { StagehandAPIConstructorParams, StartSessionParams, StartSessionResult } from "./v3/types/api";
-import { GotoOptions } from "./v3/types/playwright";
-import { ActOptions, ActResult, AgentConfig, ExtractOptions, ExtractResult, ObserveOptions, Action } from "./v3/types/stagehand";
-import { AgentExecuteOptions, AgentResult } from "@/lib/v3/types/agent";
-export declare class StagehandAPI {
-    private apiKey;
-    private projectId;
-    private sessionId?;
-    private modelApiKey;
-    private logger;
-    private fetchWithCookies;
-    constructor({ apiKey, projectId, logger }: StagehandAPIConstructorParams);
-    init({ modelName, modelApiKey, domSettleTimeoutMs, verbose, debugDom, systemPrompt, selfHeal, waitForCaptchaSolves, actionTimeoutMs, browserbaseSessionCreateParams, browserbaseSessionID, }: StartSessionParams): Promise<StartSessionResult>;
-    act(options: ActOptions | Action): Promise<ActResult>;
-    extract<T extends z.AnyZodObject>(options: ExtractOptions<T>): Promise<ExtractResult<T>>;
-    observe(options?: ObserveOptions): Promise<Action[]>;
-    goto(url: string, options?: GotoOptions): Promise<void>;
-    agentExecute(agentConfig: AgentConfig, executeOptions: AgentExecuteOptions): Promise<AgentResult>;
-    end(): Promise<Response>;
-    private execute;
-    private request;
-}

package/dist/lib/browserbaseDefaults.d.ts

@@ -1,9 +0,0 @@
-import Browserbase from "@browserbasehq/sdk";
-export type BrowserbaseSessionCreateParams = Omit<Browserbase.Sessions.SessionCreateParams, "projectId"> & {
-    projectId?: string;
-};
-export declare const DEFAULT_BROWSERBASE_VIEWPORT: {
-    readonly width: 1288;
-    readonly height: 711;
-};
-export declare function applyDefaultBrowserSettingsViewport(params?: BrowserbaseSessionCreateParams): BrowserbaseSessionCreateParams;

package/dist/lib/cache/ActionCache.d.ts

@@ -1,62 +0,0 @@
-import { LogLine } from "../../types/log";
-import { BaseCache, CacheEntry } from "./BaseCache";
-export interface PlaywrightCommand {
-    method: string;
-    args: string[];
-}
-export interface ActionEntry extends CacheEntry {
-    data: {
-        playwrightCommand: PlaywrightCommand;
-        componentString: string;
-        xpaths: string[];
-        newStepString: string;
-        completed: boolean;
-        previousSelectors: string[];
-        action: string;
-    };
-}
-/**
- * ActionCache handles logging and retrieving actions along with their Playwright commands.
- */
-export declare class ActionCache extends BaseCache<ActionEntry> {
-    constructor(logger: (message: LogLine) => void, cacheDir?: string, cacheFile?: string);
-    addActionStep({ url, action, previousSelectors, playwrightCommand, componentString, xpaths, newStepString, completed, requestId, }: {
-        url: string;
-        action: string;
-        previousSelectors: string[];
-        playwrightCommand: PlaywrightCommand;
-        componentString: string;
-        requestId: string;
-        xpaths: string[];
-        newStepString: string;
-        completed: boolean;
-    }): Promise<void>;
-    /**
-     * Retrieves all actions for a specific trajectory.
-     * @param trajectoryId - Unique identifier for the trajectory.
-     * @param requestId - The identifier for the current request.
-     * @returns An array of TrajectoryEntry objects or null if not found.
-     */
-    getActionStep({ url, action, previousSelectors, requestId, }: {
-        url: string;
-        action: string;
-        previousSelectors: string[];
-        requestId: string;
-    }): Promise<ActionEntry["data"] | null>;
-    removeActionStep(cacheHashObj: {
-        url: string;
-        action: string;
-        previousSelectors: string[];
-        requestId: string;
-    }): Promise<void>;
-    /**
-     * Clears all actions for a specific trajectory.
-     * @param trajectoryId - Unique identifier for the trajectory.
-     * @param requestId - The identifier for the current request.
-     */
-    clearAction(requestId: string): Promise<void>;
-    /**
-     * Resets the entire action cache.
-     */
-    resetCache(): Promise<void>;
-}

package/dist/lib/cache/BaseCache.d.ts

@@ -1,66 +0,0 @@
-import { LogLine } from "../../types/log";
-export interface CacheEntry {
-    timestamp: number;
-    data: unknown;
-    requestId: string;
-}
-export interface CacheStore {
-    [key: string]: CacheEntry;
-}
-export declare class BaseCache<T extends CacheEntry> {
-    private readonly CACHE_MAX_AGE_MS;
-    private readonly CLEANUP_PROBABILITY;
-    protected cacheDir: string;
-    protected cacheFile: string;
-    protected lockFile: string;
-    protected logger: (message: LogLine) => void;
-    private readonly LOCK_TIMEOUT_MS;
-    protected lockAcquired: boolean;
-    protected lockAcquireFailures: number;
-    protected requestIdToUsedHashes: {
-        [key: string]: string[];
-    };
-    constructor(logger: (message: LogLine) => void, cacheDir?: string, cacheFile?: string);
-    private setupProcessHandlers;
-    protected ensureCacheDirectory(): void;
-    protected createHash(data: unknown): string;
-    protected sleep(ms: number): Promise<void>;
-    acquireLock(): Promise<boolean>;
-    releaseLock(): void;
-    /**
-     * Cleans up stale cache entries that exceed the maximum age.
-     */
-    cleanupStaleEntries(): Promise<void>;
-    protected readCache(): CacheStore;
-    protected writeCache(cache: CacheStore): void;
-    /**
-     * Retrieves data from the cache based on the provided options.
-     * @param hashObj - The options used to generate the cache key.
-     * @param requestId - The identifier for the current request.
-     * @returns The cached data if available, otherwise null.
-     */
-    get(hashObj: Record<string, unknown> | string, requestId: string): Promise<T["data"] | null>;
-    /**
-     * Stores data in the cache based on the provided options and requestId.
-     * @param hashObj - The options used to generate the cache key.
-     * @param data - The data to be cached.
-     * @param requestId - The identifier for the cache entry.
-     */
-    set(hashObj: Record<string, unknown>, data: T["data"], requestId: string): Promise<void>;
-    delete(hashObj: Record<string, unknown>): Promise<void>;
-    /**
-     * Tracks the usage of a hash with a specific requestId.
-     * @param requestId - The identifier for the current request.
-     * @param hash - The cache key hash.
-     */
-    protected trackRequestIdUsage(requestId: string, hash: string): void;
-    /**
-     * Deletes all cache entries associated with a specific requestId.
-     * @param requestId - The identifier for the request whose cache entries should be deleted.
-     */
-    deleteCacheForRequestId(requestId: string): Promise<void>;
-    /**
-     * Resets the entire cache by clearing the cache file.
-     */
-    resetCache(): void;
-}

package/dist/lib/cache/LLMCache.d.ts

@@ -1,22 +0,0 @@
-import { BaseCache, CacheEntry } from "./BaseCache";
-export declare class LLMCache extends BaseCache<CacheEntry> {
-    constructor(logger: (message: {
-        category?: string;
-        message: string;
-        level?: number;
-    }) => void, cacheDir?: string, cacheFile?: string);
-    /**
-     * Overrides the get method to track used hashes by requestId.
-     * @param options - The options used to generate the cache key.
-     * @param requestId - The identifier for the current request.
-     * @returns The cached data if available, otherwise null.
-     */
-    get<T>(options: Record<string, unknown>, requestId: string): Promise<T | null>;
-    /**
-     * Overrides the set method to include cache cleanup logic.
-     * @param options - The options used to generate the cache key.
-     * @param data - The data to be cached.
-     * @param requestId - The identifier for the current request.
-     */
-    set(options: Record<string, unknown>, data: unknown, requestId: string): Promise<void>;
-}

package/dist/lib/cache.d.ts

@@ -1,29 +0,0 @@
-/**
- * A file system cache to skip inference when repeating steps
- * It also acts as the source of truth for identifying previously seen actions and observations
- */
-declare class Cache {
-    disabled: boolean;
-    constructor({ disabled }?: {
-        disabled?: boolean;
-    });
-    readObservations(): any;
-    readActions(): any;
-    writeObservations({ key, value, }: {
-        key: string;
-        value: {
-            id: string;
-            result: string;
-        };
-    }): void;
-    writeActions({ key, value, }: {
-        key: string;
-        value: {
-            id: string;
-            result: string;
-        };
-    }): void;
-    evictCache(): void;
-    private initCache;
-}
-export default Cache;

package/dist/lib/dom/build/scriptContent.d.ts

@@ -1 +0,0 @@
-export declare const scriptContent = "(() => {\n  // lib/dom/elementCheckUtils.ts\n  function isElementNode(node) {\n    return node.nodeType === Node.ELEMENT_NODE;\n  }\n  function isTextNode(node) {\n    return node.nodeType === Node.TEXT_NODE && Boolean(node.textContent?.trim());\n  }\n\n  // lib/dom/xpathUtils.ts\n  function getParentElement(node) {\n    return isElementNode(node) ? node.parentElement : node.parentNode;\n  }\n  function getCombinations(attributes, size) {\n    const results = [];\n    function helper(start, combo) {\n      if (combo.length === size) {\n        results.push([...combo]);\n        return;\n      }\n      for (let i = start; i < attributes.length; i++) {\n        combo.push(attributes[i]);\n        helper(i + 1, combo);\n        combo.pop();\n      }\n    }\n    helper(0, []);\n    return results;\n  }\n  function isXPathFirstResultElement(xpath, target) {\n    try {\n      const result = document.evaluate(\n        xpath,\n        document.documentElement,\n        null,\n        XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,\n        null\n      );\n      return result.snapshotItem(0) === target;\n    } catch (error) {\n      console.warn(`Invalid XPath expression: ${xpath}`, error);\n      return false;\n    }\n  }\n  function escapeXPathString(value) {\n    if (value.includes(\"'\")) {\n      if (value.includes('\"')) {\n        return \"concat(\" + value.split(/('+)/).map((part) => {\n          if (part === \"'\") {\n            return `\"'\"`;\n          } else if (part.startsWith(\"'\") && part.endsWith(\"'\")) {\n            return `\"${part}\"`;\n          } else {\n            return `'${part}'`;\n          }\n        }).join(\",\") + \")\";\n      } else {\n        return `\"${value}\"`;\n      }\n    } else {\n      return `'${value}'`;\n    }\n  }\n  async function generateXPathsForElement(element) {\n    if (!element) return [];\n    const [complexXPath, standardXPath, idBasedXPath] = await Promise.all([\n      generateComplexXPath(element),\n      generateStandardXPath(element),\n      generatedIdBasedXPath(element)\n    ]);\n    return [standardXPath, ...idBasedXPath ? [idBasedXPath] : [], complexXPath];\n  }\n  async function generateComplexXPath(element) {\n    const parts = [];\n    let currentElement = element;\n    while (currentElement && (isTextNode(currentElement) || isElementNode(currentElement))) {\n      if (isElementNode(currentElement)) {\n        const el = currentElement;\n        let selector = el.tagName.toLowerCase();\n        const attributePriority = [\n          \"data-qa\",\n          \"data-component\",\n          \"data-role\",\n          \"role\",\n          \"aria-role\",\n          \"type\",\n          \"name\",\n          \"aria-label\",\n          \"placeholder\",\n          \"title\",\n          \"alt\"\n        ];\n        const attributes = attributePriority.map((attr) => {\n          let value = el.getAttribute(attr);\n          if (attr === \"href-full\" && value) {\n            value = el.getAttribute(\"href\");\n          }\n          return value ? { attr: attr === \"href-full\" ? \"href\" : attr, value } : null;\n        }).filter((attr) => attr !== null);\n        let uniqueSelector = \"\";\n        for (let i = 1; i <= attributes.length; i++) {\n          const combinations = getCombinations(attributes, i);\n          for (const combo of combinations) {\n            const conditions = combo.map((a) => `@${a.attr}=${escapeXPathString(a.value)}`).join(\" and \");\n            const xpath2 = `//${selector}[${conditions}]`;\n            if (isXPathFirstResultElement(xpath2, el)) {\n              uniqueSelector = xpath2;\n              break;\n            }\n          }\n          if (uniqueSelector) break;\n        }\n        if (uniqueSelector) {\n          parts.unshift(uniqueSelector.replace(\"//\", \"\"));\n          break;\n        } else {\n          const parent = getParentElement(el);\n          if (parent) {\n            const siblings = Array.from(parent.children).filter(\n              (sibling) => sibling.tagName === el.tagName\n            );\n            const index = siblings.indexOf(el) + 1;\n            selector += siblings.length > 1 ? `[${index}]` : \"\";\n          }\n          parts.unshift(selector);\n        }\n      }\n      currentElement = getParentElement(currentElement);\n    }\n    const xpath = \"//\" + parts.join(\"/\");\n    return xpath;\n  }\n  async function generateStandardXPath(element) {\n    const parts = [];\n    while (element && (isTextNode(element) || isElementNode(element))) {\n      let index = 0;\n      let hasSameTypeSiblings = false;\n      const siblings = element.parentElement ? Array.from(element.parentElement.childNodes) : [];\n      for (let i = 0; i < siblings.length; i++) {\n        const sibling = siblings[i];\n        if (sibling.nodeType === element.nodeType && sibling.nodeName === element.nodeName) {\n          index = index + 1;\n          hasSameTypeSiblings = true;\n          if (sibling.isSameNode(element)) {\n            break;\n          }\n        }\n      }\n      if (element.nodeName !== \"#text\") {\n        const tagName = element.nodeName.toLowerCase();\n        const pathIndex = hasSameTypeSiblings ? `[${index}]` : \"\";\n        parts.unshift(`${tagName}${pathIndex}`);\n      }\n      element = element.parentElement;\n    }\n    return parts.length ? `/${parts.join(\"/\")}` : \"\";\n  }\n  async function generatedIdBasedXPath(element) {\n    if (isElementNode(element) && element.id) {\n      return `//*[@id='${element.id}']`;\n    }\n    return null;\n  }\n\n  // types/stagehandErrors.ts\n  var StagehandError = class extends Error {\n    constructor(message) {\n      super(message);\n      this.name = this.constructor.name;\n    }\n  };\n  var StagehandDomProcessError = class extends StagehandError {\n    constructor(message) {\n      super(`Error Processing Dom: ${message}`);\n    }\n  };\n\n  // lib/dom/utils.ts\n  function canElementScroll(elem) {\n    if (typeof elem.scrollTo !== \"function\") {\n      console.warn(\"canElementScroll: .scrollTo is not a function.\");\n      return false;\n    }\n    try {\n      const originalTop = elem.scrollTop;\n      elem.scrollTo({\n        top: originalTop + 100,\n        left: 0,\n        behavior: \"instant\"\n      });\n      if (elem.scrollTop === originalTop) {\n        throw new StagehandDomProcessError(\"scrollTop did not change\");\n      }\n      elem.scrollTo({\n        top: originalTop,\n        left: 0,\n        behavior: \"instant\"\n      });\n      return true;\n    } catch (error) {\n      console.warn(\"canElementScroll error:\", error.message || error);\n      return false;\n    }\n  }\n  function getNodeFromXpath(xpath) {\n    return document.evaluate(\n      xpath,\n      document.documentElement,\n      null,\n      XPathResult.FIRST_ORDERED_NODE_TYPE,\n      null\n    ).singleNodeValue;\n  }\n  function waitForElementScrollEnd(element, idleMs = 100) {\n    return new Promise((resolve) => {\n      let scrollEndTimer;\n      const handleScroll = () => {\n        clearTimeout(scrollEndTimer);\n        scrollEndTimer = window.setTimeout(() => {\n          element.removeEventListener(\"scroll\", handleScroll);\n          resolve();\n        }, idleMs);\n      };\n      element.addEventListener(\"scroll\", handleScroll, { passive: true });\n      handleScroll();\n    });\n  }\n\n  // lib/dom/process.ts\n  function getScrollableElements(topN) {\n    const docEl = document.documentElement;\n    const scrollableElements = [docEl];\n    const allElements = document.querySelectorAll(\"*\");\n    for (const elem of allElements) {\n      const style = window.getComputedStyle(elem);\n      const overflowY = style.overflowY;\n      const isPotentiallyScrollable = overflowY === \"auto\" || overflowY === \"scroll\" || overflowY === \"overlay\";\n      if (isPotentiallyScrollable) {\n        const candidateScrollDiff = elem.scrollHeight - elem.clientHeight;\n        if (candidateScrollDiff > 0 && canElementScroll(elem)) {\n          scrollableElements.push(elem);\n        }\n      }\n    }\n    scrollableElements.sort((a, b) => b.scrollHeight - a.scrollHeight);\n    if (topN !== void 0) {\n      return scrollableElements.slice(0, topN);\n    }\n    return scrollableElements;\n  }\n  async function getScrollableElementXpaths(topN) {\n    const scrollableElems = getScrollableElements(topN);\n    const xpaths = [];\n    for (const elem of scrollableElems) {\n      const allXPaths = await generateXPathsForElement(elem);\n      const firstXPath = allXPaths?.[0] || \"\";\n      xpaths.push(firstXPath);\n    }\n    return xpaths;\n  }\n  (() => {\n    const closedRoots = /* @__PURE__ */ new WeakMap();\n    const nativeAttachShadow = Element.prototype.attachShadow;\n    Element.prototype.attachShadow = function(init) {\n      const root = nativeAttachShadow.call(this, init);\n      if (init.mode === \"closed\") closedRoots.set(this, root);\n      return root;\n    };\n    const backdoor = {\n      getClosedRoot: (host) => closedRoots.get(host),\n      queryClosed: (host, selector) => {\n        const root = closedRoots.get(host);\n        return root ? Array.from(root.querySelectorAll(selector)) : [];\n      },\n      xpathClosed: (host, xp) => {\n        const root = closedRoots.get(host);\n        if (!root) return [];\n        const it = document.evaluate(\n          xp,\n          root,\n          null,\n          XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,\n          null\n        );\n        const out = [];\n        for (let i = 0; i < it.snapshotLength; ++i) {\n          const n = it.snapshotItem(i);\n          if (n) out.push(n);\n        }\n        return out;\n      }\n    };\n    if (!(\"__stagehand__\" in window)) {\n      Object.defineProperty(window, \"__stagehand__\", {\n        value: backdoor,\n        enumerable: false,\n        writable: false,\n        configurable: false\n      });\n    }\n  })();\n  window.getScrollableElementXpaths = getScrollableElementXpaths;\n  window.getNodeFromXpath = getNodeFromXpath;\n  window.waitForElementScrollEnd = waitForElementScrollEnd;\n})();\n";

package/dist/lib/dom/elementCheckUtils.d.ts

@@ -1,2 +0,0 @@
-export declare function isElementNode(node: Node): node is Element;
-export declare function isTextNode(node: Node): node is Text;

package/dist/lib/dom/genDomScripts.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/dom/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./process";
-export * from "./utils";

package/dist/lib/dom/process.d.ts

@@ -1,17 +0,0 @@
-/**
- * Finds and returns a list of scrollable elements on the page,
- * ordered from the element with the largest scrollHeight to the smallest.
- *
- * @param topN Optional maximum number of scrollable elements to return.
- *             If not provided, all found scrollable elements are returned.
- * @returns An array of HTMLElements sorted by descending scrollHeight.
- */
-export declare function getScrollableElements(topN?: number): HTMLElement[];
-/**
- * Calls getScrollableElements, then for each element calls generateXPaths,
- * and returns the first XPath for each.
- *
- * @param topN (optional) integer limit on how many scrollable elements to process
- * @returns string[] list of XPaths (1 for each scrollable element)
- */
-export declare function getScrollableElementXpaths(topN?: number): Promise<string[]>;

package/dist/lib/dom/utils.d.ts

@@ -1,7 +0,0 @@
-/**
- * Tests if the element actually responds to .scrollTo(...)
- * and that scrollTop changes as expected.
- */
-export declare function canElementScroll(elem: HTMLElement): boolean;
-export declare function getNodeFromXpath(xpath: string): Node;
-export declare function waitForElementScrollEnd(element: HTMLElement, idleMs?: number): Promise<void>;

package/dist/lib/dom/xpathUtils.d.ts

@@ -1,14 +0,0 @@
-/**
- * Escapes a string for use in an XPath expression.
- * Handles special characters, including single and double quotes.
- * @param value - The string to escape.
- * @returns The escaped string safe for XPath.
- */
-export declare function escapeXPathString(value: string): string;
-/**
- * Generates both a complicated XPath and a standard XPath for a given DOM element.
- * @param element - The target DOM element.
- * @param documentOverride - Optional document override.
- * @returns An object containing both XPaths.
- */
-export declare function generateXPathsForElement(element: ChildNode): Promise<string[]>;

package/dist/lib/handlers/actHandler.d.ts

@@ -1,33 +0,0 @@
-import { LogLine } from "../../types/log";
-import { LLMClient } from "../llm/LLMClient";
-import { StagehandPage } from "../StagehandPage";
-import { ActResult, ObserveResult, ActOptions } from "@/types/stagehand";
-import { StagehandObserveHandler } from "@/lib/handlers/observeHandler";
-/**
- * NOTE: Vision support has been removed from this version of Stagehand.
- * If useVision or verifierUseVision is set to true, a warning is logged and
- * the flow continues as if vision = false.
- */
-export declare class StagehandActHandler {
-    private readonly stagehandPage;
-    private readonly logger;
-    private readonly selfHeal;
-    private readonly experimental;
-    constructor({ logger, stagehandPage, selfHeal, experimental, }: {
-        logger: (logLine: LogLine) => void;
-        stagehandPage: StagehandPage;
-        selfHeal: boolean;
-        experimental: boolean;
-    });
-    /**
-     * Perform an immediate Playwright action based on an ObserveResult object
-     * that was returned from `page.observe(...)`.
-     */
-    actFromObserveResult(observe: ObserveResult, domSettleTimeoutMs?: number): Promise<ActResult>;
-    /**
-     * Perform an act based on an instruction.
-     * This method will observe the page and then perform the act on the first element returned.
-     */
-    observeAct(actionOrOptions: ActOptions, observeHandler: StagehandObserveHandler, llmClient: LLMClient, requestId: string): Promise<ActResult>;
-    private _performPlaywrightMethod;
-}

package/dist/lib/handlers/cuaAgentHandler.d.ts

@@ -1,58 +0,0 @@
-import { AgentExecuteOptions, AgentHandlerOptions, AgentResult } from "@/types/agent";
-import { ToolSet } from "ai/dist";
-import { LogLine } from "../../types/log";
-import { StagehandPage } from "../StagehandPage";
-import { AgentClient } from "../agent/AgentClient";
-import { StagehandAgent } from "../agent/StagehandAgent";
-import { Stagehand } from "../index";
-export declare class CuaAgentHandler {
-    private stagehand;
-    private stagehandPage;
-    private agent;
-    private provider;
-    private logger;
-    private agentClient;
-    private options;
-    private screenshotCollector?;
-    private highlightCursor;
-    constructor(stagehand: Stagehand, stagehandPage: StagehandPage, logger: (message: LogLine) => void, options: AgentHandlerOptions, tools?: ToolSet);
-    private setupAgentClient;
-    /**
-     * Execute a task with the agent
-     */
-    execute(optionsOrInstruction: AgentExecuteOptions | string): Promise<AgentResult>;
-    /**
-     * Execute a single action on the page
-     */
-    private executeAction;
-    private updateClientViewport;
-    private updateClientUrl;
-    getAgent(): StagehandAgent;
-    getClient(): AgentClient;
-    captureAndSendScreenshot(): Promise<unknown>;
-    /**
-     * Inject a cursor element into the page for visual feedback
-     */
-    private injectCursor;
-    /**
-     * Update the cursor position on the page
-     */
-    private updateCursorPosition;
-    /**
-     * Animate a click at the given position
-     */
-    private animateClick;
-    private get page();
-    /**
-     * Set the screenshot collector for this agent handler
-     */
-    setScreenshotCollector(collector: any): void;
-    /**
-     * Get the screenshot collector
-     */
-    getScreenshotCollector(): any;
-    /**
-     * Set the tools for this agent handler
-     */
-    setTools(tools: ToolSet): void;
-}

package/dist/lib/handlers/extractHandler.d.ts

@@ -1,54 +0,0 @@
-import { z } from "zod/v3";
-import { ZodPathSegments } from "../../types/stagehand";
-import { LLMClient } from "../llm/LLMClient";
-import { StagehandPage } from "../StagehandPage";
-import { Stagehand } from "../index";
-export declare class StagehandExtractHandler {
-    private readonly stagehand;
-    private readonly stagehandPage;
-    private readonly logger;
-    private readonly userProvidedInstructions?;
-    private readonly experimental;
-    constructor({ stagehand, logger, stagehandPage, userProvidedInstructions, experimental, }: {
-        stagehand: Stagehand;
-        logger: (message: {
-            category?: string;
-            message: string;
-            level?: number;
-            auxiliary?: {
-                [key: string]: {
-                    value: string;
-                    type: string;
-                };
-            };
-        }) => void;
-        stagehandPage: StagehandPage;
-        userProvidedInstructions?: string;
-        experimental: boolean;
-    });
-    extract<T extends z.AnyZodObject>({ instruction, schema, content, llmClient, requestId, domSettleTimeoutMs, useTextExtract, selector, iframes, }?: {
-        instruction?: string;
-        schema?: T;
-        content?: z.infer<T>;
-        chunksSeen?: Array<number>;
-        llmClient?: LLMClient;
-        requestId?: string;
-        domSettleTimeoutMs?: number;
-        useTextExtract?: boolean;
-        selector?: string;
-        iframes?: boolean;
-    }): Promise<z.infer<T>>;
-    private extractPageText;
-    private domExtract;
-}
-/**
- * Scans the provided Zod schema for any `z.string().url()` fields and
- * replaces them with `z.number()`.
- *
- * @param schema - The Zod object schema to transform.
- * @returns A tuple containing:
- *   1. The transformed schema (or the original schema if no changes were needed).
- *   2. An array of {@link ZodPathSegments} objects representing all the replaced URL fields,
- *      with each path segment showing where in the schema the replacement occurred.
- */
-export declare function transformUrlStringsToNumericIds<T extends z.ZodObject<z.ZodRawShape>>(schema: T): [T, ZodPathSegments[]];

package/dist/lib/handlers/handlerUtils/actHandlerUtils.d.ts

@@ -1,21 +0,0 @@
-import { Page, Locator, FrameLocator } from "playwright";
-import { MethodHandlerContext } from "@/types/act";
-export declare function deepLocatorWithShadow(root: Page | FrameLocator, xpath: string): Promise<Locator>;
-export declare function deepLocator(root: Page | FrameLocator, xpath: string): Locator;
-/**
- * A mapping of playwright methods that may be chosen by the LLM to their
- * implementation.
- */
-export declare const methodHandlerMap: Record<string, (ctx: MethodHandlerContext) => Promise<void>>;
-export declare function scrollToNextChunk(ctx: MethodHandlerContext): Promise<void>;
-export declare function scrollToPreviousChunk(ctx: MethodHandlerContext): Promise<void>;
-export declare function scrollElementIntoView(ctx: MethodHandlerContext): Promise<void>;
-export declare function scrollElementToPercentage(ctx: MethodHandlerContext): Promise<void>;
-export declare function fillOrType(ctx: MethodHandlerContext): Promise<void>;
-export declare function pressKey(ctx: MethodHandlerContext): Promise<void>;
-export declare function selectOption(ctx: MethodHandlerContext): Promise<void>;
-export declare function clickElement(ctx: MethodHandlerContext): Promise<void>;
-/**
- * Fallback method: if method is not in our map but *is* a valid Playwright locator method.
- */
-export declare function fallbackLocatorMethod(ctx: MethodHandlerContext): Promise<void>;

package/dist/lib/handlers/observeHandler.d.ts

@@ -1,40 +0,0 @@
-import { LogLine } from "../../types/log";
-import { Stagehand } from "../index";
-import { LLMClient } from "../llm/LLMClient";
-import { StagehandPage } from "../StagehandPage";
-export declare class StagehandObserveHandler {
-    private readonly stagehand;
-    private readonly logger;
-    private readonly stagehandPage;
-    private readonly experimental;
-    private readonly userProvidedInstructions?;
-    constructor({ stagehand, logger, stagehandPage, userProvidedInstructions, experimental, }: {
-        stagehand: Stagehand;
-        logger: (logLine: LogLine) => void;
-        stagehandPage: StagehandPage;
-        userProvidedInstructions?: string;
-        experimental: boolean;
-    });
-    observe({ instruction, llmClient, requestId, returnAction, onlyVisible, drawOverlay, fromAct, iframes, }: {
-        instruction: string;
-        llmClient: LLMClient;
-        requestId: string;
-        domSettleTimeoutMs?: number;
-        returnAction?: boolean;
-        /**
-         * @deprecated The `onlyVisible` parameter has no effect in this version of Stagehand and will be removed in later versions.
-         */
-        onlyVisible?: boolean;
-        drawOverlay?: boolean;
-        fromAct?: boolean;
-        iframes?: boolean;
-    }): Promise<({
-        selector: string;
-        description: string;
-    } | {
-        selector: string;
-        method: string;
-        arguments: string[];
-        description: string;
-    })[]>;
-}