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

package/dist/lib/agent/AnthropicCUAClient.d.ts

@@ -1,56 +0,0 @@
-import { AgentAction, AgentExecutionOptions, AgentResult, AgentType, AnthropicContentBlock, AnthropicMessage, AnthropicToolResult, ToolUseItem } from "@/types/agent";
-import { LogLine } from "@/types/log";
-import { ToolSet } from "ai";
-import { AgentClient } from "./AgentClient";
-export type ResponseInputItem = AnthropicMessage | AnthropicToolResult;
-/**
- * Client for Anthropic's Computer Use API
- * This implementation uses the official Anthropic Messages API for Computer Use
- */
-export declare class AnthropicCUAClient extends AgentClient {
-    private apiKey;
-    private baseURL?;
-    private client;
-    lastMessageId?: string;
-    private currentViewport;
-    private currentUrl?;
-    private screenshotProvider?;
-    private actionHandler?;
-    private thinkingBudget;
-    private tools?;
-    constructor(type: AgentType, modelName: string, userProvidedInstructions?: string, clientOptions?: Record<string, unknown>, tools?: ToolSet);
-    setViewport(width: number, height: number): void;
-    setCurrentUrl(url: string): void;
-    setScreenshotProvider(provider: () => Promise<string>): void;
-    setActionHandler(handler: (action: AgentAction) => Promise<void>): void;
-    setTools(tools: ToolSet): void;
-    /**
-     * Execute a task with the Anthropic CUA
-     * This is the main entry point for the agent
-     * @implements AgentClient.execute
-     */
-    execute(executionOptions: AgentExecutionOptions): Promise<AgentResult>;
-    executeStep(inputItems: ResponseInputItem[], logger: (message: LogLine) => void): Promise<{
-        actions: AgentAction[];
-        message: string;
-        completed: boolean;
-        nextInputItems: ResponseInputItem[];
-        usage: {
-            input_tokens: number;
-            output_tokens: number;
-            inference_time_ms: number;
-        };
-    }>;
-    private createInitialInputItems;
-    getAction(inputItems: ResponseInputItem[]): Promise<{
-        content: AnthropicContentBlock[];
-        id: string;
-        usage: Record<string, number>;
-    }>;
-    takeAction(toolUseItems: ToolUseItem[], logger: (message: LogLine) => void): Promise<AnthropicToolResult[]>;
-    private convertToolUseToAction;
-    captureScreenshot(options?: {
-        base64Image?: string;
-        currentUrl?: string;
-    }): Promise<string>;
-}

package/dist/lib/agent/GoogleCUAClient.d.ts

@@ -1,63 +0,0 @@
-import { LogLine } from "../../types/log";
-import { AgentAction, AgentResult, AgentType, AgentExecutionOptions } from "@/types/agent";
-import { AgentClient } from "./AgentClient";
-/**
- * Client for Google's Computer Use Assistant API
- * This implementation uses the Google Generative AI SDK for Computer Use
- */
-export declare class GoogleCUAClient extends AgentClient {
-    private apiKey;
-    private client;
-    private currentViewport;
-    private currentUrl?;
-    private screenshotProvider?;
-    private actionHandler?;
-    private history;
-    private environment;
-    private generateContentConfig;
-    constructor(type: AgentType, modelName: string, userProvidedInstructions?: string, clientOptions?: Record<string, unknown>);
-    setViewport(width: number, height: number): void;
-    setCurrentUrl(url: string): void;
-    setScreenshotProvider(provider: () => Promise<string>): void;
-    setActionHandler(handler: (action: AgentAction) => Promise<void>): void;
-    setTools(): void;
-    /**
-     * Execute a task with the Google CUA
-     * This is the main entry point for the agent
-     * @implements AgentClient.execute
-     */
-    execute(executionOptions: AgentExecutionOptions): Promise<AgentResult>;
-    /**
-     * Initialize conversation history with the initial instruction
-     */
-    private initializeHistory;
-    /**
-     * Execute a single step of the agent
-     */
-    executeStep(logger: (message: LogLine) => void): Promise<{
-        actions: AgentAction[];
-        message: string;
-        completed: boolean;
-        usage: {
-            input_tokens: number;
-            output_tokens: number;
-            inference_time_ms: number;
-        };
-    }>;
-    /**
-     * Process the response from Google's API
-     */
-    private processResponse;
-    /**
-     * Convert Google function call to Stagehand action
-     */
-    private convertFunctionCallToAction;
-    /**
-     * Normalize coordinates from Google's 0-1000 range to actual viewport dimensions
-     */
-    private normalizeCoordinates;
-    captureScreenshot(options?: {
-        base64Image?: string;
-        currentUrl?: string;
-    }): Promise<string>;
-}

package/dist/lib/agent/OpenAICUAClient.d.ts

@@ -1,65 +0,0 @@
-import { LogLine } from "../../types/log";
-import { AgentAction, AgentResult, AgentType, AgentExecutionOptions, ResponseInputItem, ResponseItem } from "@/types/agent";
-import { AgentClient } from "./AgentClient";
-import { ToolSet } from "ai/dist";
-/**
- * Client for OpenAI's Computer Use Assistant API
- * This implementation uses the official OpenAI Responses API for Computer Use
- */
-export declare class OpenAICUAClient extends AgentClient {
-    private apiKey;
-    private organization?;
-    private baseURL;
-    private client;
-    lastResponseId?: string;
-    private currentViewport;
-    private currentUrl?;
-    private screenshotProvider?;
-    private actionHandler?;
-    private reasoningItems;
-    private environment;
-    private tools?;
-    constructor(type: AgentType, modelName: string, userProvidedInstructions?: string, clientOptions?: Record<string, unknown>, tools?: ToolSet);
-    setViewport(width: number, height: number): void;
-    setCurrentUrl(url: string): void;
-    setScreenshotProvider(provider: () => Promise<string>): void;
-    setActionHandler(handler: (action: AgentAction) => Promise<void>): void;
-    setTools(tools: ToolSet): void;
-    /**
-     * Execute a task with the OpenAI CUA
-     * This is the main entry point for the agent
-     * @implements AgentClient.execute
-     */
-    execute(executionOptions: AgentExecutionOptions): Promise<AgentResult>;
-    /**
-     * Execute a single step of the agent
-     * This coordinates the flow: Request → Get Action → Execute Action
-     */
-    executeStep(inputItems: ResponseInputItem[], previousResponseId: string | undefined, logger: (message: LogLine) => void): Promise<{
-        actions: AgentAction[];
-        message: string;
-        completed: boolean;
-        nextInputItems: ResponseInputItem[];
-        responseId: string;
-        usage: {
-            input_tokens: number;
-            output_tokens: number;
-            inference_time_ms: number;
-        };
-    }>;
-    private isComputerCallItem;
-    private isFunctionCallItem;
-    private createInitialInputItems;
-    getAction(inputItems: ResponseInputItem[], previousResponseId?: string): Promise<{
-        output: ResponseItem[];
-        responseId: string;
-        usage: Record<string, number>;
-    }>;
-    takeAction(output: ResponseItem[], logger: (message: LogLine) => void): Promise<ResponseInputItem[]>;
-    private convertComputerCallToAction;
-    private convertFunctionCallToAction;
-    captureScreenshot(options?: {
-        base64Image?: string;
-        currentUrl?: string;
-    }): Promise<string>;
-}

package/dist/lib/agent/StagehandAgent.d.ts

@@ -1,15 +0,0 @@
-import { LogLine } from "@/types/log";
-import { AgentExecuteOptions, AgentResult } from "@/types/agent";
-import { AgentClient } from "./AgentClient";
-/**
- * Main interface for agent operations in Stagehand
- * This class provides methods for executing tasks with an agent
- */
-export declare class StagehandAgent {
-    private client;
-    private logger;
-    constructor(client: AgentClient, logger: (message: LogLine) => void);
-    execute(optionsOrInstruction: AgentExecuteOptions | string): Promise<AgentResult>;
-    getModelName(): string;
-    getAgentType(): string;
-}

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

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

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

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

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

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

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

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

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

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