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

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

@@ -0,0 +1,59 @@
+import { z } from "zod/v3";
+import { Stagehand } from "../../index";
+export declare const createActTool: (stagehand: Stagehand, executionModel?: string) => import("ai/dist").Tool<z.ZodObject<{
+    action: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    action?: string;
+}, {
+    action?: string;
+}>, {
+    success: boolean;
+    error: string;
+    isIframe: boolean;
+    action?: undefined;
+    playwrightArguments?: undefined;
+} | {
+    success: boolean;
+    action: string;
+    isIframe: boolean;
+    playwrightArguments: {
+        description: string;
+        method: string;
+        arguments: string[];
+        selector: string;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+    isIframe?: undefined;
+    action?: undefined;
+    playwrightArguments?: undefined;
+}> & {
+    execute: (args: {
+        action?: string;
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+        error: string;
+        isIframe: boolean;
+        action?: undefined;
+        playwrightArguments?: undefined;
+    } | {
+        success: boolean;
+        action: string;
+        isIframe: boolean;
+        playwrightArguments: {
+            description: string;
+            method: string;
+            arguments: string[];
+            selector: string;
+        };
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        isIframe?: undefined;
+        action?: undefined;
+        playwrightArguments?: undefined;
+    }>;
+};

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

@@ -0,0 +1,11 @@
+import { z } from "zod/v3";
+import { Stagehand } from "../../index";
+export declare const createAriaTreeTool: (stagehand: Stagehand) => import("ai/dist").Tool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {
+    content: string;
+    pageUrl: string;
+}> & {
+    execute: (args: {}, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        content: string;
+        pageUrl: string;
+    }>;
+};

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

@@ -0,0 +1,22 @@
+import { z } from "zod/v3";
+export declare const createCloseTool: () => import("ai/dist").Tool<z.ZodObject<{
+    reasoning: z.ZodString;
+    success: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    reasoning?: string;
+    success?: boolean;
+}, {
+    reasoning?: string;
+    success?: boolean;
+}>, {
+    success: boolean;
+    reasoning: string;
+}> & {
+    execute: (args: {
+        reasoning?: string;
+        success?: boolean;
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+        reasoning: string;
+    }>;
+};

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

@@ -0,0 +1,38 @@
+import { z } from "zod/v3";
+import { Stagehand } from "../../index";
+import { LogLine } from "@/types/log";
+export declare const createExtractTool: (stagehand: Stagehand, executionModel?: string, logger?: (message: LogLine) => void) => import("ai/dist").Tool<z.ZodObject<{
+    instruction: z.ZodString;
+    schema: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    schema?: string;
+    instruction?: string;
+}, {
+    schema?: string;
+    instruction?: string;
+}>, {
+    success: boolean;
+    data: any;
+    timestamp: number;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    timestamp: number;
+    data?: undefined;
+}> & {
+    execute: (args: {
+        schema?: string;
+        instruction?: string;
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+        data: any;
+        timestamp: number;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        timestamp: number;
+        data?: undefined;
+    }>;
+};

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

@@ -0,0 +1,37 @@
+import { z } from "zod/v3";
+import { Stagehand } from "../../index";
+export declare const createFillFormTool: (stagehand: Stagehand, executionModel?: string) => import("ai/dist").Tool<z.ZodObject<{
+    fields: z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value?: string;
+        action?: string;
+    }, {
+        value?: string;
+        action?: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    fields?: {
+        value?: string;
+        action?: string;
+    }[];
+}, {
+    fields?: {
+        value?: string;
+        action?: string;
+    }[];
+}>, {
+    success: boolean;
+    actions: import("@/types/stagehand").ActResult[];
+}> & {
+    execute: (args: {
+        fields?: {
+            value?: string;
+            action?: string;
+        }[];
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+        actions: import("@/types/stagehand").ActResult[];
+    }>;
+};

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

@@ -0,0 +1,29 @@
+import { z } from "zod/v3";
+import { Stagehand } from "../../index";
+export declare const createGotoTool: (stagehand: Stagehand) => import("ai/dist").Tool<z.ZodObject<{
+    url: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    url?: string;
+}, {
+    url?: string;
+}>, {
+    success: boolean;
+    url: string;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+    url?: undefined;
+}> & {
+    execute: (args: {
+        url?: string;
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+        url: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        url?: undefined;
+    }>;
+};

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

@@ -0,0 +1,257 @@
+import { Stagehand } from "../../index";
+import { LogLine } from "@/types/log";
+export interface AgentToolOptions {
+    executionModel?: string;
+    logger?: (message: LogLine) => void;
+}
+export declare function createAgentTools(stagehand: Stagehand, options?: AgentToolOptions): {
+    act: import("ai/dist").Tool<import("zod/v3").ZodObject<{
+        action: import("zod/v3").ZodString;
+    }, "strip", import("zod/v3").ZodTypeAny, {
+        action?: string;
+    }, {
+        action?: string;
+    }>, {
+        success: boolean;
+        error: string;
+        isIframe: boolean;
+        action?: undefined;
+        playwrightArguments?: undefined;
+    } | {
+        success: boolean;
+        action: string;
+        isIframe: boolean;
+        playwrightArguments: {
+            description: string;
+            method: string;
+            arguments: string[];
+            selector: string;
+        };
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        isIframe?: undefined;
+        action?: undefined;
+        playwrightArguments?: undefined;
+    }> & {
+        execute: (args: {
+            action?: string;
+        }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+            success: boolean;
+            error: string;
+            isIframe: boolean;
+            action?: undefined;
+            playwrightArguments?: undefined;
+        } | {
+            success: boolean;
+            action: string;
+            isIframe: boolean;
+            playwrightArguments: {
+                description: string;
+                method: string;
+                arguments: string[];
+                selector: string;
+            };
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: any;
+            isIframe?: undefined;
+            action?: undefined;
+            playwrightArguments?: undefined;
+        }>;
+    };
+    ariaTree: import("ai/dist").Tool<import("zod/v3").ZodObject<{}, "strip", import("zod/v3").ZodTypeAny, {}, {}>, {
+        content: string;
+        pageUrl: string;
+    }> & {
+        execute: (args: {}, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+            content: string;
+            pageUrl: string;
+        }>;
+    };
+    close: import("ai/dist").Tool<import("zod/v3").ZodObject<{
+        reasoning: import("zod/v3").ZodString;
+        success: import("zod/v3").ZodBoolean;
+    }, "strip", import("zod/v3").ZodTypeAny, {
+        reasoning?: string;
+        success?: boolean;
+    }, {
+        reasoning?: string;
+        success?: boolean;
+    }>, {
+        success: boolean;
+        reasoning: string;
+    }> & {
+        execute: (args: {
+            reasoning?: string;
+            success?: boolean;
+        }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+            success: boolean;
+            reasoning: string;
+        }>;
+    };
+    extract: import("ai/dist").Tool<import("zod/v3").ZodObject<{
+        instruction: import("zod/v3").ZodString;
+        schema: import("zod/v3").ZodString;
+    }, "strip", import("zod/v3").ZodTypeAny, {
+        schema?: string;
+        instruction?: string;
+    }, {
+        schema?: string;
+        instruction?: string;
+    }>, {
+        success: boolean;
+        data: any;
+        timestamp: number;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        timestamp: number;
+        data?: undefined;
+    }> & {
+        execute: (args: {
+            schema?: string;
+            instruction?: string;
+        }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+            success: boolean;
+            data: any;
+            timestamp: number;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            timestamp: number;
+            data?: undefined;
+        }>;
+    };
+    fillForm: import("ai/dist").Tool<import("zod/v3").ZodObject<{
+        fields: import("zod/v3").ZodArray<import("zod/v3").ZodObject<{
+            action: import("zod/v3").ZodString;
+            value: import("zod/v3").ZodString;
+        }, "strip", import("zod/v3").ZodTypeAny, {
+            value?: string;
+            action?: string;
+        }, {
+            value?: string;
+            action?: string;
+        }>, "many">;
+    }, "strip", import("zod/v3").ZodTypeAny, {
+        fields?: {
+            value?: string;
+            action?: string;
+        }[];
+    }, {
+        fields?: {
+            value?: string;
+            action?: string;
+        }[];
+    }>, {
+        success: boolean;
+        actions: import("@/types/stagehand").ActResult[];
+    }> & {
+        execute: (args: {
+            fields?: {
+                value?: string;
+                action?: string;
+            }[];
+        }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+            success: boolean;
+            actions: import("@/types/stagehand").ActResult[];
+        }>;
+    };
+    goto: import("ai/dist").Tool<import("zod/v3").ZodObject<{
+        url: import("zod/v3").ZodString;
+    }, "strip", import("zod/v3").ZodTypeAny, {
+        url?: string;
+    }, {
+        url?: string;
+    }>, {
+        success: boolean;
+        url: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        url?: undefined;
+    }> & {
+        execute: (args: {
+            url?: string;
+        }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+            success: boolean;
+            url: string;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: any;
+            url?: undefined;
+        }>;
+    };
+    navback: import("ai/dist").Tool<import("zod/v3").ZodObject<{
+        reasoning: import("zod/v3").ZodString;
+    }, "strip", import("zod/v3").ZodTypeAny, {
+        reasoning?: string;
+    }, {
+        reasoning?: string;
+    }>, {
+        success: boolean;
+    }> & {
+        execute: (args: {
+            reasoning?: string;
+        }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+            success: boolean;
+        }>;
+    };
+    screenshot: import("ai/dist").Tool<import("zod/v3").ZodObject<{}, "strip", import("zod/v3").ZodTypeAny, {}, {}>, {
+        base64: string;
+        timestamp: number;
+        pageUrl: string;
+    }> & {
+        execute: (args: {}, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+            base64: string;
+            timestamp: number;
+            pageUrl: string;
+        }>;
+    };
+    scroll: import("ai/dist").Tool<import("zod/v3").ZodObject<{
+        pixels: import("zod/v3").ZodNumber;
+        direction: import("zod/v3").ZodEnum<["up", "down"]>;
+    }, "strip", import("zod/v3").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;
+        }>;
+    };
+    wait: import("ai/dist").Tool<import("zod/v3").ZodObject<{
+        timeMs: import("zod/v3").ZodNumber;
+    }, "strip", import("zod/v3").ZodTypeAny, {
+        timeMs?: number;
+    }, {
+        timeMs?: number;
+    }>, {
+        success: boolean;
+        waited: number;
+    }> & {
+        execute: (args: {
+            timeMs?: number;
+        }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+            success: boolean;
+            waited: number;
+        }>;
+    };
+};
+export type AgentTools = ReturnType<typeof createAgentTools>;

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

@@ -0,0 +1,17 @@
+import { z } from "zod/v3";
+import { Stagehand } from "../../index";
+export declare const createNavBackTool: (stagehand: Stagehand) => import("ai/dist").Tool<z.ZodObject<{
+    reasoning: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    reasoning?: string;
+}, {
+    reasoning?: string;
+}>, {
+    success: boolean;
+}> & {
+    execute: (args: {
+        reasoning?: string;
+    }, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        success: boolean;
+    }>;
+};

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

@@ -0,0 +1,13 @@
+import { z } from "zod/v3";
+import { Stagehand } from "../../index";
+export declare const createScreenshotTool: (stagehand: Stagehand) => import("ai/dist").Tool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {
+    base64: string;
+    timestamp: number;
+    pageUrl: string;
+}> & {
+    execute: (args: {}, options: import("ai/dist").ToolExecutionOptions) => PromiseLike<{
+        base64: string;
+        timestamp: number;
+        pageUrl: string;
+    }>;
+};

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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,10 @@
+/**
+ * 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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,13 @@
+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/browserbaseDefaults.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,62 @@
+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>;
+}