@browserbasehq/orca 3.1.0-patch.0 → 3.1.0-patch.2

package/dist/cjs/lib/inference.d.ts

@@ -0,0 +1,65 @@
+import { LogLine } from "./v3/types/public/logs.js";
+import { LLMClient } from "./v3/llm/LLMClient.js";
+import type { InferStagehandSchema, StagehandZodObject } from "./v3/zodCompat.js";
+export type { LLMParsedResponse, LLMUsage } from "./v3/llm/LLMClient.js";
+export declare function extract<T extends StagehandZodObject>({ instruction, domElements, schema, llmClient, logger, userProvidedInstructions, logInferenceToFile, }: {
+    instruction: string;
+    domElements: string;
+    schema: T;
+    llmClient: LLMClient;
+    userProvidedInstructions?: string;
+    logger: (message: LogLine) => void;
+    logInferenceToFile?: boolean;
+}): Promise<InferStagehandSchema<T> & {
+    metadata: {
+        completed: boolean;
+        progress: string;
+    };
+    prompt_tokens: number;
+    completion_tokens: number;
+    reasoning_tokens: number;
+    cached_input_tokens: number;
+    inference_time_ms: number;
+}>;
+export declare function observe({ instruction, domElements, llmClient, userProvidedInstructions, logger, logInferenceToFile, supportedActions, }: {
+    instruction: string;
+    domElements: string;
+    llmClient: LLMClient;
+    userProvidedInstructions?: string;
+    logger: (message: LogLine) => void;
+    logInferenceToFile?: boolean;
+    supportedActions?: string[];
+}): Promise<{
+    elements: {
+        elementId: string;
+        description: string;
+        method: string;
+        arguments: string[];
+    }[];
+    prompt_tokens: number;
+    completion_tokens: number;
+    reasoning_tokens: number;
+    cached_input_tokens: number;
+    inference_time_ms: number;
+}>;
+export declare function act({ instruction, domElements, llmClient, userProvidedInstructions, logger, logInferenceToFile, }: {
+    instruction: string;
+    domElements: string;
+    llmClient: LLMClient;
+    userProvidedInstructions?: string;
+    logger: (message: LogLine) => void;
+    logInferenceToFile?: boolean;
+}): Promise<{
+    element: {
+        elementId: string;
+        description: string;
+        method: string;
+        arguments: string[];
+    };
+    prompt_tokens: number;
+    completion_tokens: number;
+    reasoning_tokens: number;
+    cached_input_tokens: number;
+    inference_time_ms: number;
+    twoStep: boolean;
+}>;

package/dist/cjs/lib/inferenceLogUtils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Appends a new entry to the act_summary.json file, then writes the file back out.
+ */
+export declare function appendSummary<T>(inferenceType: string, entry: T): void;
+/**
+ * Writes `data` as JSON into a file in `directory`, using a prefix plus timestamp.
+ * Returns both the file name and the timestamp used, so you can log them.
+ */
+export declare function writeTimestampedTxtFile(directory: string, prefix: string, data: unknown): {
+    fileName: string;
+    timestamp: string;
+};

package/dist/cjs/lib/logger.d.ts

@@ -0,0 +1,69 @@
+import pino from "pino";
+import { LogLine } from "./v3/types/public/logs.js";
+export interface LoggerOptions {
+    pretty?: boolean;
+    level?: pino.Level;
+    destination?: pino.DestinationStream;
+    usePino?: boolean;
+}
+/**
+ * Creates a configured Pino logger instance
+ */
+export declare function createLogger(options?: LoggerOptions): import("pino").Logger<never, boolean>;
+/**
+ * StagehandLogger class that wraps Pino for our specific needs
+ *
+ * LOGGING PRECEDENCE:
+ *
+ * Test environments:
+ *   - External logger provided -> external logger only.
+ *   - No external logger -> console fallback only (Pino disabled).
+ *
+ * Non-test environments:
+ *   - usePino === true -> emit via Pino and also call the external logger when present.
+ *   - usePino === false -> disable Pino; use the external logger when present, otherwise console fallback.
+ *   - usePino === undefined -> prefer the external logger when present; otherwise use Pino.
+ *
+ * SHARED PINO OPTIMIZATION:
+ * We maintain a single shared Pino instance when `usePino` is enabled.
+ * This prevents spawning a new worker thread for every Stagehand instance
+ * (which happens when `pino-pretty` transport is used), eliminating the
+ * memory/RSS growth observed when many Stagehand objects are created and
+ * disposed within the same process (e.g. a request-per-instance API).
+ */
+export declare class StagehandLogger {
+    /**
+     * Shared Pino logger instance across all StagehandLogger instances.
+     * First instance to enable Pino creates it, subsequent instances reuse it.
+     */
+    private static sharedPinoLogger;
+    private logger?;
+    private verbose;
+    private externalLogger?;
+    private usePino;
+    private isTest;
+    constructor(options?: LoggerOptions, externalLogger?: (logLine: LogLine) => void);
+    /**
+     * Set the verbosity level
+     */
+    setVerbosity(level: 0 | 1 | 2): void;
+    /**
+     * Log a message using our LogLine format
+     */
+    log(logLine: LogLine): void;
+    /**
+     * Helper to format auxiliary data for structured logging
+     */
+    private formatAuxiliaryData;
+    /**
+     * Convenience methods for different log levels
+     */
+    error(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    debug(message: string, data?: Record<string, unknown>): void;
+    /**
+     * Convert a plain object to our auxiliary format
+     */
+    private convertToAuxiliary;
+}

package/dist/cjs/lib/modelUtils.d.ts

@@ -0,0 +1,11 @@
+import { ClientOptions, ModelConfiguration } from "./v3/types/public/model.js";
+export declare function splitModelName(model: string): {
+    provider: string;
+    modelName: string;
+};
+export declare function resolveModel(model: string | ModelConfiguration): {
+    provider: string;
+    modelName: string;
+    clientOptions: ClientOptions;
+    isCua: boolean;
+};

package/dist/cjs/lib/prompt.d.ts

@@ -0,0 +1,14 @@
+import { ChatMessage } from "./v3/llm/LLMClient.js";
+export declare function buildUserInstructionsString(userProvidedInstructions?: string): string;
+export declare function buildExtractSystemPrompt(isUsingPrintExtractedDataTool?: boolean, userProvidedInstructions?: string): ChatMessage;
+export declare function buildExtractUserPrompt(instruction: string, domElements: string, isUsingPrintExtractedDataTool?: boolean): ChatMessage;
+export declare function buildMetadataSystemPrompt(): ChatMessage;
+export declare function buildMetadataPrompt(instruction: string, extractionResponse: object): ChatMessage;
+export declare function buildObserveSystemPrompt(userProvidedInstructions?: string, supportedActions?: string[]): ChatMessage;
+export declare function buildObserveUserMessage(instruction: string, domElements: string): ChatMessage;
+export declare function buildActSystemPrompt(userProvidedInstructions?: string): ChatMessage;
+export declare function buildActPrompt(action: string, supportedActions: string[], variables?: Record<string, string>): string;
+export declare function buildStepTwoPrompt(originalUserAction: string, previousAction: string, supportedActions: string[], variables?: Record<string, string>): string;
+export declare function buildOperatorSystemPrompt(goal: string): ChatMessage;
+export declare function buildCuaDefaultSystemPrompt(): string;
+export declare function buildGoogleCUASystemPrompt(): ChatMessage;

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

@@ -0,0 +1,68 @@
+import { Schema } from "@google/genai";
+import { z, ZodTypeAny } from "zod";
+import { LogLine } from "./v3/types/public/logs.js";
+import { ModelProvider } from "./v3/types/public/model.js";
+import { ZodPathSegments } from "./v3/types/private/internal.js";
+import type { StagehandZodSchema } from "./v3/zodCompat.js";
+export declare function getZFactory(schema: StagehandZodSchema): typeof z;
+export declare function validateZodSchema(schema: StagehandZodSchema, data: unknown): boolean;
+/**
+ * Detects if the code is running in the Bun runtime environment.
+ * @returns {boolean} True if running in Bun, false otherwise.
+ */
+export declare function isRunningInBun(): boolean;
+export declare function toGeminiSchema(zodSchema: StagehandZodSchema): Schema;
+export declare function getZodType(schema: StagehandZodSchema): string;
+/**
+ * Recursively traverses a given Zod schema, scanning for any fields of type `z.string().url()`.
+ * For each such field, it replaces the `z.string().url()` with `z.number()`.
+ *
+ * This function is used internally by higher-level utilities (e.g., transforming entire object schemas)
+ * and handles nested objects, arrays, unions, intersections, optionals.
+ *
+ * @param schema - The Zod schema to transform.
+ * @param currentPath - An array of string/number keys representing the current schema path (used internally for recursion).
+ * @returns A two-element tuple:
+ *   1. The updated Zod schema, with any `.url()` fields replaced by `z.number()`.
+ *   2. An array of {@link ZodPathSegments} objects representing each replaced field, including the path segments.
+ */
+export declare function transformSchema(schema: StagehandZodSchema, currentPath: Array<string | number>): [StagehandZodSchema, ZodPathSegments[]];
+/**
+ * Once we get the final extracted object that has numeric IDs in place of URLs,
+ * use `injectUrls` to walk the object and replace numeric IDs
+ * with the real URL strings from idToUrlMapping. The `path` may include `*`
+ * for array indices (indicating "all items in the array").
+ */
+export declare function injectUrls(obj: unknown, path: Array<string | number>, idToUrlMapping: Record<string, string>): void;
+/**
+ * Mapping from LLM provider names to their corresponding environment variable names for API keys.
+ */
+export declare const providerEnvVarMap: Partial<Record<ModelProvider | string, string | Array<string>>>;
+/**
+ * Loads an API key for a provider, checking environment variables.
+ * @param provider The name of the provider (e.g., 'openai', 'anthropic')
+ * @param logger Optional logger for info/error messages
+ * @returns The API key if found, undefined otherwise
+ */
+export declare function loadApiKeyFromEnv(provider: string | undefined, logger: (logLine: LogLine) => void): string | undefined;
+export declare function trimTrailingTextNode(path: string | undefined): string | undefined;
+export interface JsonSchemaProperty {
+    type: string;
+    enum?: unknown[];
+    items?: JsonSchemaProperty;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    minimum?: number;
+    maximum?: number;
+    description?: string;
+    format?: string;
+}
+export interface JsonSchema extends JsonSchemaProperty {
+    type: string;
+}
+/**
+ * Converts a JSON Schema object to a Zod schema
+ * @param schema The JSON Schema object to convert
+ * @returns A Zod schema equivalent to the input JSON Schema
+ */
+export declare function jsonSchemaToZod(schema: JsonSchema): ZodTypeAny;

package/dist/cjs/lib/v3/agent/AgentClient.d.ts

@@ -0,0 +1,19 @@
+import { AgentAction, AgentResult, AgentType, AgentExecutionOptions } from "../types/public/agent.js";
+import { ClientOptions } from "../types/public/model.js";
+/**
+ * Abstract base class for agent clients
+ * This provides a common interface for all agent implementations
+ */
+export declare abstract class AgentClient {
+    type: AgentType;
+    modelName: string;
+    clientOptions: ClientOptions;
+    userProvidedInstructions?: string;
+    constructor(type: AgentType, modelName: string, userProvidedInstructions?: string);
+    abstract execute(options: AgentExecutionOptions): Promise<AgentResult>;
+    abstract captureScreenshot(options?: Record<string, unknown>): Promise<unknown>;
+    abstract setViewport(width: number, height: number): void;
+    abstract setCurrentUrl(url: string): void;
+    abstract setScreenshotProvider(provider: () => Promise<string>): void;
+    abstract setActionHandler(handler: (action: AgentAction) => Promise<void>): void;
+}

package/dist/cjs/lib/v3/agent/AgentProvider.d.ts

@@ -0,0 +1,20 @@
+import { ToolSet } from "ai/dist";
+import { AgentProviderType } from "../types/public/agent.js";
+import { LogLine } from "../types/public/logs.js";
+import { ClientOptions } from "../types/public/model.js";
+import { AgentClient } from "./AgentClient.js";
+export declare const modelToAgentProviderMap: Record<string, AgentProviderType>;
+/**
+ * Provider for agent clients
+ * This class is responsible for creating the appropriate agent client
+ * based on the provider type
+ */
+export declare class AgentProvider {
+    private logger;
+    /**
+     * Create a new agent provider
+     */
+    constructor(logger: (message: LogLine) => void);
+    getClient(modelName: string, clientOptions?: ClientOptions, userProvidedInstructions?: string, tools?: ToolSet): AgentClient;
+    static getAgentProvider(modelName: string): AgentProviderType;
+}

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

@@ -0,0 +1,57 @@
+import { AgentAction, AgentResult, AgentType, AnthropicContentBlock, AnthropicMessage, AnthropicToolResult, AgentExecutionOptions, ToolUseItem } from "../types/public/agent.js";
+import { LogLine } from "../types/public/logs.js";
+import { ClientOptions } from "../types/public/model.js";
+import { ToolSet } from "ai";
+import { AgentClient } from "./AgentClient.js";
+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?: ClientOptions, 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/cjs/lib/v3/agent/GoogleCUAClient.d.ts

@@ -0,0 +1,74 @@
+import { LogLine } from "../types/public/logs.js";
+import { AgentAction, AgentResult, AgentType, AgentExecutionOptions, SafetyConfirmationHandler } from "../types/public/agent.js";
+import { ClientOptions } from "../types/public/model.js";
+import { AgentClient } from "./AgentClient.js";
+import { ToolSet } from "ai";
+/**
+ * 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;
+    private tools?;
+    private baseURL?;
+    private safetyConfirmationHandler?;
+    constructor(type: AgentType, modelName: string, userProvidedInstructions?: string, clientOptions?: ClientOptions, 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;
+    setSafetyConfirmationHandler(handler?: SafetyConfirmationHandler): void;
+    private handleSafetyConfirmation;
+    /**
+     * Update the generateContentConfig with current tools
+     */
+    private updateGenerateContentConfig;
+    /**
+     * 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 viewport dimensions
+     */
+    private normalizeCoordinates;
+    captureScreenshot(options?: {
+        base64Image?: string;
+        currentUrl?: string;
+    }): Promise<string>;
+}

package/dist/cjs/lib/v3/agent/MicrosoftCUAClient.d.ts

@@ -0,0 +1,71 @@
+import { AgentAction, AgentResult, AgentType, AgentExecutionOptions } from "../types/public/agent.js";
+import { ClientOptions } from "../types/public/model.js";
+import { AgentClient } from "./AgentClient.js";
+/**
+ * Client for FARA (Function-based Autonomous Research Agent) by Microsoft
+ * This implementation uses OpenAI-compatible API with XML-based tool calling
+ */
+export declare class MicrosoftCUAClient extends AgentClient {
+    private apiKey;
+    private baseURL;
+    private client;
+    private currentViewport;
+    private currentUrl?;
+    private screenshotProvider?;
+    private actionHandler?;
+    private conversationHistory;
+    private actionHistory;
+    private maxImages;
+    private temperature;
+    private facts;
+    private readonly MLM_PROCESSOR_IM_CFG;
+    private resizedViewport;
+    constructor(type: AgentType, modelName: string, userProvidedInstructions?: string, clientOptions?: ClientOptions);
+    setViewport(width: number, height: number): void;
+    setCurrentUrl(url: string): void;
+    setScreenshotProvider(provider: () => Promise<string>): void;
+    setActionHandler(handler: (action: AgentAction) => Promise<void>): void;
+    /**
+     * Smart resize algorithm from FARA
+     * Ensures dimensions are divisible by factor and within pixel limits
+     */
+    private smartResize;
+    /**
+     * Generate system prompt with tool description
+     * Simplified to match Python's minimal approach
+     */
+    private generateSystemPrompt;
+    /**
+     * Parse thoughts and action from model response
+     * FARA uses XML-based tool calling: <tool_call>\n{...}\n</tool_call>
+     */
+    private parseThoughtsAndAction;
+    /**
+     * Convert FARA function call to Stagehand AgentAction
+     */
+    private convertFunctionCallToAction;
+    /**
+     * Capture a screenshot and return as base64 data URL
+     */
+    captureScreenshot(): Promise<string>;
+    /**
+     * Remove old screenshots from history
+     * Matches Python's maybe_remove_old_screenshots
+     */
+    private maybeRemoveOldScreenshots;
+    /**
+     * Reconstruct history for API call
+     * Merges conceptual chat history with raw action history
+     */
+    private reconstructHistory;
+    /**
+     * Execute a single step
+     */
+    private executeStep;
+    /**
+     * Execute a task with the FARA CUA
+     * This is the main entry point for the agent
+     * @implements AgentClient.execute
+     */
+    execute(executionOptions: AgentExecutionOptions): Promise<AgentResult>;
+}

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

@@ -0,0 +1,69 @@
+import { LogLine } from "../types/public/logs.js";
+import { AgentAction, AgentResult, AgentType, AgentExecutionOptions, ResponseInputItem, ResponseItem, SafetyConfirmationHandler } from "../types/public/agent.js";
+import { ClientOptions } from "../types/public/model.js";
+import { AgentClient } from "./AgentClient.js";
+import { ToolSet } from "ai";
+/**
+ * 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?;
+    private safetyConfirmationHandler?;
+    constructor(type: AgentType, modelName: string, userProvidedInstructions?: string, clientOptions?: ClientOptions, 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;
+    setSafetyConfirmationHandler(handler?: SafetyConfirmationHandler): 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 handleSafetyConfirmation;
+    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/cjs/lib/v3/agent/prompts/agentSystemPrompt.d.ts

@@ -0,0 +1,12 @@
+import type { AgentToolMode } from "../../types/public/agent.js";
+export interface AgentSystemPromptOptions {
+    url: string;
+    executionInstruction: string;
+    mode: AgentToolMode;
+    systemInstructions?: string;
+    /** Whether running on Browserbase (enables captcha solver messaging) */
+    isBrowserbase?: boolean;
+    /** Tools to exclude from the system prompt */
+    excludeTools?: string[];
+}
+export declare function buildAgentSystemPrompt(options: AgentSystemPromptOptions): string;

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

@@ -0,0 +1,12 @@
+import type { V3 } from "../../v3.js";
+import type { Action } from "../../types/public/methods.js";
+export declare const actTool: (v3: V3, executionModel?: string) => import("ai").Tool<{
+    action: string;
+}, {
+    success: boolean;
+    action: string;
+    playwrightArguments?: Action;
+} | {
+    success: boolean;
+    error: any;
+}>;

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

@@ -0,0 +1,5 @@
+import type { V3 } from "../../v3.js";
+export declare const ariaTreeTool: (v3: V3) => import("ai").Tool<Record<string, never>, {
+    content: string;
+    pageUrl: string;
+}>;

package/dist/cjs/lib/v3/agent/tools/click.d.ts

@@ -0,0 +1,6 @@
+import type { V3 } from "../../v3.js";
+import type { ClickToolResult } from "../../types/public/agent.js";
+export declare const clickTool: (v3: V3, provider?: string) => import("ai").Tool<{
+    describe: string;
+    coordinates: number[];
+}, ClickToolResult>;

package/dist/cjs/lib/v3/agent/tools/clickAndHold.d.ts

@@ -0,0 +1,14 @@
+import type { V3 } from "../../v3.js";
+export declare const clickAndHoldTool: (v3: V3, provider?: string) => import("ai").Tool<{
+    describe: string;
+    duration: number;
+    coordinates: number[];
+}, {
+    success: boolean;
+    describe: string;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    describe?: undefined;
+}>;

package/dist/cjs/lib/v3/agent/tools/dragAndDrop.d.ts

@@ -0,0 +1,7 @@
+import type { V3 } from "../../v3.js";
+import type { DragAndDropToolResult } from "../../types/public/agent.js";
+export declare const dragAndDropTool: (v3: V3, provider?: string) => import("ai").Tool<{
+    describe: string;
+    startCoordinates: number[];
+    endCoordinates: number[];
+}, DragAndDropToolResult>;

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

@@ -0,0 +1,20 @@
+import type { V3 } from "../../v3.js";
+export declare const extractTool: (v3: V3, executionModel?: string) => import("ai").Tool<{
+    instruction: string;
+    schema?: {
+        [x: string]: unknown;
+        type?: string;
+        properties?: Record<string, unknown>;
+        items?: unknown;
+        enum?: string[];
+        format?: "email" | "uuid" | "url";
+    };
+}, {
+    success: boolean;
+    result: unknown;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    result?: undefined;
+}>;

package/dist/cjs/lib/v3/agent/tools/fillFormVision.d.ts

@@ -0,0 +1,12 @@
+import type { V3 } from "../../v3.js";
+import type { FillFormVisionToolResult } from "../../types/public/agent.js";
+export declare const fillFormVisionTool: (v3: V3, provider?: string) => import("ai").Tool<{
+    fields: {
+        action: string;
+        value: string;
+        coordinates: {
+            x: number;
+            y: number;
+        };
+    }[];
+}, FillFormVisionToolResult>;