@skyvern/client 1.0.0 → 1.0.3

package/dist/cjs/library/Skyvern.js

@@ -0,0 +1,315 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Skyvern = void 0;
+const playwright_1 = require("playwright");
+const Client_js_1 = require("../Client.js");
+const environments_js_1 = require("../environments.js");
+const SkyvernBrowser_js_1 = require("./SkyvernBrowser.js");
+const logger_js_1 = require("./logger.js");
+const core = __importStar(require("../core/index.js"));
+/**
+ * Main entry point for the Skyvern SDK.
+ *
+ * This class provides methods to launch and connect to browsers (both local and cloud-hosted),
+ * and access the Skyvern API client for task and workflow management. It combines browser
+ * automation capabilities with AI-powered task execution.
+ *
+ * @example
+ * ```typescript
+ * // Remote mode: Connect to Skyvern Cloud (API key required)
+ * const skyvern = new Skyvern({ apiKey: "your-api-key" });
+ *
+ * // Launch a cloud browser
+ * const browser = await skyvern.launchCloudBrowser();
+ * const page = await browser.getWorkingPage();
+ *
+ * // Execute AI-powered tasks
+ * await page.agent.runTask("Fill out the form and submit it");
+ * ```
+ */
+class Skyvern extends Client_js_1.SkyvernClient {
+    constructor(options) {
+        var _a, _b;
+        super(Object.assign(Object.assign({}, options), { environment: (_a = options.environment) !== null && _a !== void 0 ? _a : environments_js_1.SkyvernEnvironment.Cloud }));
+        this._browsers = new Set();
+        this._apiKey = options.apiKey;
+        this._environment = ((_b = options.environment) !== null && _b !== void 0 ? _b : environments_js_1.SkyvernEnvironment.Cloud);
+    }
+    get environment() {
+        return this._environment;
+    }
+    runTask(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__runTaskWithCompletion(request, requestOptions));
+    }
+    __runTaskWithCompletion(request, requestOptions) {
+        const _super = Object.create(null, {
+            runTask: { get: () => super.runTask }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const { waitForCompletion, timeout } = request, taskRequest = __rest(request, ["waitForCompletion", "timeout"]);
+            const response = yield _super.runTask.call(this, taskRequest, requestOptions).withRawResponse();
+            if (waitForCompletion) {
+                const completedRun = yield this._waitForRunCompletion(response.data.run_id, timeout !== null && timeout !== void 0 ? timeout : 1800);
+                return { data: completedRun, rawResponse: response.rawResponse };
+            }
+            return response;
+        });
+    }
+    runWorkflow(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__runWorkflowWithCompletion(request, requestOptions));
+    }
+    __runWorkflowWithCompletion(request, requestOptions) {
+        const _super = Object.create(null, {
+            runWorkflow: { get: () => super.runWorkflow }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const { waitForCompletion, timeout } = request, workflowRequest = __rest(request, ["waitForCompletion", "timeout"]);
+            const response = yield _super.runWorkflow.call(this, workflowRequest, requestOptions).withRawResponse();
+            if (waitForCompletion) {
+                const completedRun = yield this._waitForRunCompletion(response.data.run_id, timeout !== null && timeout !== void 0 ? timeout : 1800);
+                return { data: completedRun, rawResponse: response.rawResponse };
+            }
+            return response;
+        });
+    }
+    login(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__loginWithCompletion(request, requestOptions));
+    }
+    __loginWithCompletion(request, requestOptions) {
+        const _super = Object.create(null, {
+            login: { get: () => super.login }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const { waitForCompletion, timeout } = request, loginRequest = __rest(request, ["waitForCompletion", "timeout"]);
+            const response = yield _super.login.call(this, loginRequest, requestOptions).withRawResponse();
+            if (waitForCompletion) {
+                const completedRun = yield this._waitForRunCompletion(response.data.run_id, timeout !== null && timeout !== void 0 ? timeout : 1800);
+                return { data: completedRun, rawResponse: response.rawResponse };
+            }
+            return response;
+        });
+    }
+    downloadFiles(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__downloadFilesWithCompletion(request, requestOptions));
+    }
+    __downloadFilesWithCompletion(request, requestOptions) {
+        const _super = Object.create(null, {
+            downloadFiles: { get: () => super.downloadFiles }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const { waitForCompletion, timeout } = request, downloadFilesRequest = __rest(request, ["waitForCompletion", "timeout"]);
+            const response = yield _super.downloadFiles.call(this, downloadFilesRequest, requestOptions).withRawResponse();
+            if (waitForCompletion) {
+                const completedRun = yield this._waitForRunCompletion(response.data.run_id, timeout !== null && timeout !== void 0 ? timeout : 1800);
+                return { data: completedRun, rawResponse: response.rawResponse };
+            }
+            return response;
+        });
+    }
+    /**
+     * Launch a new cloud-hosted browser session.
+     *
+     * This creates a new browser session in Skyvern's cloud infrastructure and connects to it.
+     *
+     * @param options - Optional configuration
+     * @param options.timeout - Timeout in minutes for the session. Timeout is applied after the session is started.
+     *        Must be between 5 and 1440. Defaults to 60.
+     * @param options.proxyLocation - Geographic proxy location to route the browser traffic through.
+     *        This is only available in Skyvern Cloud.
+     *
+     * @returns SkyvernBrowser instance connected to the new cloud session.
+     */
+    launchCloudBrowser(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._ensureCloudEnvironment();
+            const browserSession = yield this.createBrowserSession({
+                timeout: options === null || options === void 0 ? void 0 : options.timeout,
+                proxy_location: options === null || options === void 0 ? void 0 : options.proxyLocation,
+            });
+            logger_js_1.LOG.info("Launched new cloud browser session", { browser_session_id: browserSession.browser_session_id });
+            return this._connectToCloudBrowserSession(browserSession);
+        });
+    }
+    /**
+     * Connect to an existing cloud-hosted browser session by ID.
+     *
+     * @param browserSessionId - The ID of the cloud browser session to connect to.
+     *
+     * @returns SkyvernBrowser instance connected to the cloud session.
+     */
+    connectToCloudBrowserSession(browserSessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._ensureCloudEnvironment();
+            const browserSession = yield this.getBrowserSession(browserSessionId);
+            logger_js_1.LOG.info("Connecting to existing cloud browser session", { browser_session_id: browserSession.browser_session_id });
+            return this._connectToCloudBrowserSession(browserSession);
+        });
+    }
+    /**
+     * Get or create a cloud browser session.
+     *
+     * This method attempts to reuse the most recent available cloud browser session.
+     * If no session exists, it creates a new one. This is useful for cost efficiency
+     * and session persistence.
+     *
+     * @param options - Optional configuration
+     * @param options.timeout - Timeout in minutes for the session. Timeout is applied after the session is started.
+     *        Must be between 5 and 1440. Defaults to 60. Only used when creating a new session.
+     * @param options.proxyLocation - Geographic proxy location to route the browser traffic through.
+     *        This is only available in Skyvern Cloud. Only used when creating a new session.
+     *
+     * @returns SkyvernBrowser instance connected to an existing or new cloud session.
+     */
+    useCloudBrowser(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._ensureCloudEnvironment();
+            const browserSessions = yield this.getBrowserSessions();
+            const browserSession = browserSessions
+                .filter((s) => s.runnable_id == null)
+                .sort((a, b) => {
+                const aTime = a.started_at ? new Date(a.started_at).getTime() : 0;
+                const bTime = b.started_at ? new Date(b.started_at).getTime() : 0;
+                return bTime - aTime;
+            })[0];
+            if (!browserSession) {
+                logger_js_1.LOG.info("No existing cloud browser session found, launching a new session");
+                return this.launchCloudBrowser(options);
+            }
+            logger_js_1.LOG.info("Reusing existing cloud browser session", { browser_session_id: browserSession.browser_session_id });
+            return this._connectToCloudBrowserSession(browserSession);
+        });
+    }
+    /**
+     * Connect to an existing browser instance via Chrome DevTools Protocol (CDP).
+     *
+     * Use this to connect to a browser that's already running with CDP enabled,
+     * whether local or remote.
+     *
+     * @param cdpUrl - The CDP WebSocket URL (e.g., "http://localhost:9222").
+     *
+     * @returns SkyvernBrowser instance connected to the existing browser.
+     */
+    connectToBrowserOverCdp(cdpUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const browser = yield playwright_1.chromium.connectOverCDP(cdpUrl);
+            const browserContext = (_a = browser.contexts()[0]) !== null && _a !== void 0 ? _a : (yield browser.newContext());
+            const skyvernBrowser = new SkyvernBrowser_js_1.SkyvernBrowser(this, browserContext, { browser, browserAddress: cdpUrl });
+            this._browsers.add(skyvernBrowser);
+            return skyvernBrowser;
+        });
+    }
+    /**
+     * Close all browsers and release resources.
+     */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(Array.from(this._browsers).map((browser) => browser.close()));
+            this._browsers.clear();
+        });
+    }
+    _untrackBrowser(browser) {
+        this._browsers.delete(browser);
+    }
+    _ensureCloudEnvironment() {
+        if (this._environment !== environments_js_1.SkyvernEnvironment.Cloud && this._environment !== environments_js_1.SkyvernEnvironment.Staging) {
+            throw new Error("Cloud browser sessions are supported only in the cloud environment");
+        }
+    }
+    _connectToCloudBrowserSession(browserSession) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!browserSession.browser_address) {
+                throw new Error(`Browser address is missing for session ${browserSession.browser_session_id}`);
+            }
+            const browser = yield playwright_1.chromium.connectOverCDP(browserSession.browser_address, {
+                headers: { "x-api-key": this._apiKey },
+            });
+            const browserContext = (_a = browser.contexts()[0]) !== null && _a !== void 0 ? _a : (yield browser.newContext());
+            const skyvernBrowser = new SkyvernBrowser_js_1.SkyvernBrowser(this, browserContext, {
+                browser,
+                browserSessionId: browserSession.browser_session_id,
+            });
+            this._browsers.add(skyvernBrowser);
+            return skyvernBrowser;
+        });
+    }
+    _waitForRunCompletion(runId, timeoutSeconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            const timeoutMs = timeoutSeconds * 1000;
+            while (true) {
+                const run = yield this.getRun(runId);
+                // Check if the run is in a final state
+                const status = run.status;
+                if (status === "completed" ||
+                    status === "failed" ||
+                    status === "terminated" ||
+                    status === "timed_out" ||
+                    status === "canceled") {
+                    return run;
+                }
+                // Check timeout
+                if (Date.now() - startTime >= timeoutMs) {
+                    throw new Error(`Timeout waiting for run ${runId} to complete after ${timeoutSeconds} seconds`);
+                }
+                // Wait before polling again
+                yield new Promise((resolve) => setTimeout(resolve, 10000)); // 10 seconds
+            }
+        });
+    }
+}
+exports.Skyvern = Skyvern;

package/dist/cjs/library/SkyvernBrowser.d.ts

@@ -0,0 +1,76 @@
+import type { Browser, BrowserContext } from "playwright";
+import type { Skyvern } from "./Skyvern.js";
+import { type SkyvernBrowserPage } from "./SkyvernBrowserPage.js";
+/**
+ * A browser context wrapper that creates Skyvern-enabled pages.
+ *
+ * This class wraps a Playwright BrowserContext and provides methods to create
+ * SkyvernBrowserPage instances that combine traditional browser automation with
+ * AI-powered task execution capabilities. It manages browser session state and
+ * enables persistent browser sessions across multiple pages.
+ *
+ * @example
+ * ```typescript
+ * const skyvern = Skyvern.local();
+ * const browser = await skyvern.launchCloudBrowser();
+ *
+ * // Get or create the working page
+ * const page = await browser.getWorkingPage();
+ *
+ * // Create a new page
+ * const newPage = await browser.newPage();
+ * ```
+ */
+export declare class SkyvernBrowser {
+    private readonly _skyvern;
+    private readonly _browserContext;
+    private readonly _browser?;
+    private readonly _browserSessionId?;
+    private readonly _browserAddress?;
+    workflowRunId?: string;
+    constructor(skyvern: Skyvern, browserContext: BrowserContext, options?: {
+        browser?: Browser;
+        browserSessionId?: string;
+        browserAddress?: string;
+    });
+    get browserSessionId(): string | undefined;
+    get browserAddress(): string | undefined;
+    get skyvern(): Skyvern;
+    get context(): BrowserContext;
+    /**
+     * Get the most recent page or create a new one if none exists.
+     *
+     * This method returns the last page in the browser context, or creates a new page
+     * if the context has no pages. This is useful for continuing work on an existing
+     * page without creating unnecessary new tabs.
+     *
+     * @returns SkyvernBrowserPage: The most recent page wrapped with Skyvern capabilities.
+     */
+    getWorkingPage(): Promise<SkyvernBrowserPage>;
+    /**
+     * Create a new page (tab) in the browser context.
+     *
+     * This method always creates a new page, similar to opening a new tab in a browser.
+     * The new page will have both Playwright's standard API and Skyvern's AI capabilities.
+     *
+     * @returns SkyvernBrowserPage: A new page wrapped with Skyvern capabilities.
+     */
+    newPage(): Promise<SkyvernBrowserPage>;
+    pages(): SkyvernBrowserPage[];
+    /**
+     * Close the browser and optionally close the browser session.
+     *
+     * This method closes the browser context. If the browser is associated with a
+     * cloud browser session (has a browserSessionId), it will also close the
+     * browser session via the API, marking it as completed.
+     *
+     * @example
+     * ```typescript
+     * const browser = await skyvern.launchCloudBrowser();
+     * // ... use the browser ...
+     * await browser.close();  // Closes both browser and cloud session
+     * ```
+     */
+    close(): Promise<void>;
+    private _createSkyvernPage;
+}

package/dist/cjs/library/SkyvernBrowser.js

@@ -0,0 +1,119 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkyvernBrowser = void 0;
+const SkyvernBrowserPage_js_1 = require("./SkyvernBrowserPage.js");
+/**
+ * A browser context wrapper that creates Skyvern-enabled pages.
+ *
+ * This class wraps a Playwright BrowserContext and provides methods to create
+ * SkyvernBrowserPage instances that combine traditional browser automation with
+ * AI-powered task execution capabilities. It manages browser session state and
+ * enables persistent browser sessions across multiple pages.
+ *
+ * @example
+ * ```typescript
+ * const skyvern = Skyvern.local();
+ * const browser = await skyvern.launchCloudBrowser();
+ *
+ * // Get or create the working page
+ * const page = await browser.getWorkingPage();
+ *
+ * // Create a new page
+ * const newPage = await browser.newPage();
+ * ```
+ */
+class SkyvernBrowser {
+    constructor(skyvern, browserContext, options) {
+        this._skyvern = skyvern;
+        this._browserContext = browserContext;
+        this._browser = options === null || options === void 0 ? void 0 : options.browser;
+        this._browserSessionId = options === null || options === void 0 ? void 0 : options.browserSessionId;
+        this._browserAddress = options === null || options === void 0 ? void 0 : options.browserAddress;
+    }
+    get browserSessionId() {
+        return this._browserSessionId;
+    }
+    get browserAddress() {
+        return this._browserAddress;
+    }
+    get skyvern() {
+        return this._skyvern;
+    }
+    get context() {
+        return this._browserContext;
+    }
+    /**
+     * Get the most recent page or create a new one if none exists.
+     *
+     * This method returns the last page in the browser context, or creates a new page
+     * if the context has no pages. This is useful for continuing work on an existing
+     * page without creating unnecessary new tabs.
+     *
+     * @returns SkyvernBrowserPage: The most recent page wrapped with Skyvern capabilities.
+     */
+    getWorkingPage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pages = this._browserContext.pages();
+            const page = pages.length > 0 ? pages[pages.length - 1] : yield this._browserContext.newPage();
+            return this._createSkyvernPage(page);
+        });
+    }
+    /**
+     * Create a new page (tab) in the browser context.
+     *
+     * This method always creates a new page, similar to opening a new tab in a browser.
+     * The new page will have both Playwright's standard API and Skyvern's AI capabilities.
+     *
+     * @returns SkyvernBrowserPage: A new page wrapped with Skyvern capabilities.
+     */
+    newPage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const page = yield this._browserContext.newPage();
+            return this._createSkyvernPage(page);
+        });
+    }
+    pages() {
+        return this._browserContext.pages().map((page) => SkyvernBrowserPage_js_1.SkyvernBrowserPageCore.create(this, page));
+    }
+    /**
+     * Close the browser and optionally close the browser session.
+     *
+     * This method closes the browser context. If the browser is associated with a
+     * cloud browser session (has a browserSessionId), it will also close the
+     * browser session via the API, marking it as completed.
+     *
+     * @example
+     * ```typescript
+     * const browser = await skyvern.launchCloudBrowser();
+     * // ... use the browser ...
+     * await browser.close();  // Closes both browser and cloud session
+     * ```
+     */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._browser) {
+                yield this._browser.close();
+            }
+            else {
+                yield this._browserContext.close();
+            }
+            if (this._browserSessionId) {
+                yield this._skyvern.closeBrowserSession(this._browserSessionId);
+            }
+            this._skyvern._untrackBrowser(this);
+        });
+    }
+    _createSkyvernPage(page) {
+        return SkyvernBrowserPage_js_1.SkyvernBrowserPageCore.create(this, page);
+    }
+}
+exports.SkyvernBrowser = SkyvernBrowser;

package/dist/cjs/library/SkyvernBrowserPage.d.ts

@@ -0,0 +1,69 @@
+import type { Page } from "playwright";
+import type { SkyvernBrowser } from "./SkyvernBrowser.js";
+import { SkyvernBrowserPageAgent } from "./SkyvernBrowserPageAgent.js";
+/**
+ * A browser page wrapper that combines Playwright's page API with Skyvern's AI capabilities.
+ *
+ * This class provides a unified interface for both traditional browser automation (via Playwright)
+ * and AI-powered task execution (via Skyvern). It exposes standard page methods like click, fill,
+ * goto, etc., while also providing access to Skyvern's task and workflow execution through the
+ * `agent` attribute.
+ *
+ * @example
+ * ```typescript
+ * // Use standard Playwright methods
+ * await page.goto("https://example.com");
+ * await page.fill("#username", "user@example.com");
+ * await page.click("#login-button");
+ *
+ * // Or use Skyvern's AI capabilities
+ * await page.agent.runTask("Fill out the contact form and submit it");
+ * ```
+ */
+export declare class SkyvernBrowserPageCore {
+    private readonly _browser;
+    private readonly _page;
+    private readonly _ai;
+    readonly agent: SkyvernBrowserPageAgent;
+    private readonly _proxy;
+    private constructor();
+    static create(browser: SkyvernBrowser, page: Page): SkyvernBrowserPage;
+    get page(): Page;
+    get browser(): SkyvernBrowser;
+    click(selector: string, options?: Parameters<Page["click"]>[1]): Promise<void>;
+    click(options: {
+        prompt: string;
+    } & Partial<Parameters<Page["click"]>[1]>): Promise<void>;
+    fill(selector: string, value: string, options?: Parameters<Page["fill"]>[2]): Promise<void>;
+    fill(options: {
+        prompt: string;
+        value?: string;
+    } & Partial<Parameters<Page["fill"]>[2]>): Promise<void>;
+    selectOption(selector: string, values: string | string[], options?: Parameters<Page["selectOption"]>[2]): Promise<string[]>;
+    selectOption(options: {
+        prompt: string;
+        value?: string;
+    } & Partial<Parameters<Page["selectOption"]>[2]>): Promise<string[]>;
+    /**
+     * Perform an action on the page using AI based on a natural language prompt.
+     *
+     * @param prompt - Natural language description of the action to perform.
+     *
+     * @example
+     * ```typescript
+     * // Simple action
+     * await page.act("Click the login button");
+     * ```
+     */
+    act(prompt: string): Promise<void>;
+    extract(options: {
+        prompt: string;
+        schema?: Record<string, unknown> | unknown[] | string;
+        errorCodeMapping?: Record<string, string>;
+        intention?: string;
+        data?: string | Record<string, unknown>;
+    }): Promise<Record<string, unknown> | unknown[] | string | null>;
+    validate(prompt: string, model?: Record<string, unknown> | string): Promise<boolean>;
+    prompt(prompt: string, schema?: Record<string, unknown>, model?: Record<string, unknown> | string): Promise<Record<string, unknown> | unknown[] | string | null>;
+}
+export type SkyvernBrowserPage = SkyvernBrowserPageCore & Page;