browser-use 0.2.0 → 0.3.0

package/dist/browser/watchdogs/crash-watchdog.js

@@ -0,0 +1,296 @@
+import { BrowserConnectedEvent, BrowserErrorEvent, BrowserStoppedEvent, TabClosedEvent, TabCreatedEvent, TargetCrashedEvent, } from '../events.js';
+import { BaseWatchdog } from './base.js';
+export class CrashWatchdog extends BaseWatchdog {
+    static LISTENS_TO = [
+        BrowserConnectedEvent,
+        BrowserStoppedEvent,
+        TabCreatedEvent,
+        TabClosedEvent,
+    ];
+    static EMITS = [TargetCrashedEvent, BrowserErrorEvent];
+    _pageListeners = new Map();
+    _pendingRequests = new Map();
+    _requestIds = new WeakMap();
+    _requestCounter = 0;
+    _healthInterval = null;
+    _networkTimeoutMs = 10_000;
+    _healthCheckIntervalMs = 5_000;
+    _consecutiveUnresponsiveChecks = 0;
+    _unresponsiveThreshold = 2;
+    _monitoringInProgress = false;
+    async on_BrowserConnectedEvent() {
+        this._attachToKnownPages();
+        this._startHealthMonitor();
+    }
+    async on_TabCreatedEvent() {
+        this._attachToKnownPages();
+    }
+    async on_TabClosedEvent() {
+        this._dropDetachedPages();
+    }
+    async on_BrowserStoppedEvent() {
+        this._detachAllPages();
+        this._stopHealthMonitor();
+        this._pendingRequests.clear();
+        this._consecutiveUnresponsiveChecks = 0;
+    }
+    onDetached() {
+        this._detachAllPages();
+        this._stopHealthMonitor();
+        this._pendingRequests.clear();
+        this._consecutiveUnresponsiveChecks = 0;
+    }
+    _attachToKnownPages() {
+        for (const page of this._getKnownPages()) {
+            this._attachPage(page);
+        }
+    }
+    _dropDetachedPages() {
+        const livePages = new Set(this._getKnownPages());
+        for (const [page, listeners] of [...this._pageListeners.entries()]) {
+            if (livePages.has(page)) {
+                continue;
+            }
+            this._detachPageListeners(page, listeners);
+            this._pageListeners.delete(page);
+        }
+    }
+    _detachAllPages() {
+        for (const [page, listeners] of [...this._pageListeners.entries()]) {
+            this._detachPageListeners(page, listeners);
+        }
+        this._pageListeners.clear();
+    }
+    _attachPage(page) {
+        if (this._pageListeners.has(page)) {
+            return;
+        }
+        if (typeof page?.on !== 'function') {
+            return;
+        }
+        const crashListener = (payload) => {
+            void this._handlePageCrash(page, payload);
+        };
+        const requestListener = (payload) => {
+            this._trackRequestStart(payload);
+        };
+        const requestFinishedListener = (payload) => {
+            this._trackRequestDone(payload);
+        };
+        const requestFailedListener = (payload) => {
+            this._trackRequestDone(payload);
+        };
+        const responseListener = () => {
+            // Keep hook for future detailed response-based crash heuristics.
+        };
+        page.on('crash', crashListener);
+        page.on('request', requestListener);
+        page.on('requestfinished', requestFinishedListener);
+        page.on('requestfailed', requestFailedListener);
+        page.on('response', responseListener);
+        this._pageListeners.set(page, {
+            crash: crashListener,
+            request: requestListener,
+            requestfinished: requestFinishedListener,
+            requestfailed: requestFailedListener,
+            response: responseListener,
+        });
+    }
+    _detachPageListeners(page, listeners) {
+        if (typeof page.off === 'function') {
+            page.off('crash', listeners.crash);
+            page.off('request', listeners.request);
+            page.off('requestfinished', listeners.requestfinished);
+            page.off('requestfailed', listeners.requestfailed);
+            page.off('response', listeners.response);
+            return;
+        }
+        if (typeof page.removeListener === 'function') {
+            page.removeListener('crash', listeners.crash);
+            page.removeListener('request', listeners.request);
+            page.removeListener('requestfinished', listeners.requestfinished);
+            page.removeListener('requestfailed', listeners.requestfailed);
+            page.removeListener('response', listeners.response);
+        }
+    }
+    _getKnownPages() {
+        const pagesFromContext = typeof this.browser_session.browser_context?.pages === 'function'
+            ? this.browser_session.browser_context.pages()
+            : [];
+        const activePage = this.browser_session.agent_current_page;
+        if (!activePage) {
+            return pagesFromContext;
+        }
+        if (pagesFromContext.includes(activePage)) {
+            return pagesFromContext;
+        }
+        return [...pagesFromContext, activePage];
+    }
+    async _handlePageCrash(page, payload) {
+        const target_id = this._resolveTargetId(page);
+        const url = this._safePageUrl(page) ?? this.browser_session.active_tab?.url ?? '';
+        const errorMessage = this._normalizeCrashError(payload);
+        await this.event_bus.dispatch(new TargetCrashedEvent({
+            target_id,
+            error: errorMessage,
+        }));
+        await this.event_bus.dispatch(new BrowserErrorEvent({
+            error_type: 'TargetCrash',
+            message: errorMessage,
+            details: {
+                target_id,
+                url,
+            },
+        }));
+    }
+    _resolveTargetId(page) {
+        const pageUrl = this._safePageUrl(page);
+        if (pageUrl) {
+            const tabByUrl = this.browser_session.tabs.find((tab) => tab.url === pageUrl && tab.target_id);
+            if (tabByUrl?.target_id) {
+                return tabByUrl.target_id;
+            }
+        }
+        const activeTargetId = this.browser_session.active_tab?.target_id;
+        if (activeTargetId) {
+            return activeTargetId;
+        }
+        return (this.browser_session.session_manager.get_focused_target_id() ??
+            'unknown_target');
+    }
+    _safePageUrl(page) {
+        try {
+            return typeof page.url === 'function' ? page.url() : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    _normalizeCrashError(payload) {
+        if (payload instanceof Error) {
+            return payload.message || 'Target crashed';
+        }
+        if (typeof payload === 'string' && payload.trim().length > 0) {
+            return payload.trim();
+        }
+        if (payload && typeof payload === 'object' && 'message' in payload) {
+            const candidate = payload.message;
+            if (typeof candidate === 'string' && candidate.trim().length > 0) {
+                return candidate.trim();
+            }
+        }
+        return 'Target crashed';
+    }
+    _trackRequestStart(request) {
+        const requestObject = request;
+        if (!requestObject || typeof requestObject !== 'object') {
+            return;
+        }
+        const requestId = `req-${this._requestCounter++}`;
+        const url = typeof request?.url === 'function'
+            ? request.url()
+            : (this.browser_session.active_tab?.url ?? '');
+        const method = typeof request?.method === 'function' ? request.method() : 'GET';
+        this._requestIds.set(requestObject, requestId);
+        this._pendingRequests.set(requestId, {
+            url: typeof url === 'string' ? url : '',
+            method: typeof method === 'string' ? method : 'GET',
+            started_at: Date.now(),
+        });
+    }
+    _trackRequestDone(request) {
+        const requestObject = request;
+        if (!requestObject || typeof requestObject !== 'object') {
+            return;
+        }
+        const requestId = this._requestIds.get(requestObject);
+        if (!requestId) {
+            return;
+        }
+        this._requestIds.delete(requestObject);
+        this._pendingRequests.delete(requestId);
+    }
+    _startHealthMonitor() {
+        if (this._healthInterval) {
+            return;
+        }
+        this._healthInterval = setInterval(() => {
+            void this._runHealthCheck();
+        }, this._healthCheckIntervalMs);
+    }
+    _stopHealthMonitor() {
+        if (!this._healthInterval) {
+            return;
+        }
+        clearInterval(this._healthInterval);
+        this._healthInterval = null;
+    }
+    async _runHealthCheck() {
+        if (this._monitoringInProgress) {
+            return;
+        }
+        this._monitoringInProgress = true;
+        try {
+            await this._checkNetworkTimeouts();
+            await this._checkPageResponsiveness();
+        }
+        finally {
+            this._monitoringInProgress = false;
+        }
+    }
+    async _checkNetworkTimeouts() {
+        const now = Date.now();
+        for (const [requestId, metadata] of [...this._pendingRequests.entries()]) {
+            const ageMs = now - metadata.started_at;
+            if (ageMs < this._networkTimeoutMs) {
+                continue;
+            }
+            this._pendingRequests.delete(requestId);
+            await this.event_bus.dispatch(new BrowserErrorEvent({
+                error_type: 'NetworkTimeout',
+                message: `Request timed out after ${Math.round(ageMs / 1000)}s`,
+                details: {
+                    request_id: requestId,
+                    url: metadata.url,
+                    method: metadata.method,
+                    timeout_ms: this._networkTimeoutMs,
+                },
+            }));
+        }
+    }
+    async _checkPageResponsiveness() {
+        const page = (await this.browser_session.get_current_page());
+        if (!page?.evaluate) {
+            return;
+        }
+        const timeoutMs = 2_000;
+        try {
+            await Promise.race([
+                page.evaluate(() => document.readyState),
+                new Promise((_, reject) => {
+                    setTimeout(() => {
+                        reject(new Error('Page responsiveness check timed out'));
+                    }, timeoutMs);
+                }),
+            ]);
+            this._consecutiveUnresponsiveChecks = 0;
+        }
+        catch (error) {
+            this._consecutiveUnresponsiveChecks += 1;
+            if (this._consecutiveUnresponsiveChecks < this._unresponsiveThreshold) {
+                return;
+            }
+            this._consecutiveUnresponsiveChecks = 0;
+            await this.event_bus.dispatch(new BrowserErrorEvent({
+                error_type: 'TargetUnresponsive',
+                message: error.message || 'Target became unresponsive',
+                details: {
+                    url: this._safePageUrl(page) ??
+                        this.browser_session.active_tab?.url ??
+                        '',
+                    timeout_ms: timeoutMs,
+                },
+            }));
+        }
+    }
+}

package/dist/browser/watchdogs/default-action-watchdog.d.ts

@@ -0,0 +1,49 @@
+import { ClickCoordinateEvent, ClickElementEvent, CloseTabEvent, GetDropdownOptionsEvent, GoBackEvent, NavigateToUrlEvent, ScrollEvent, ScrollToTextEvent, SelectDropdownOptionEvent, SendKeysEvent, SwitchTabEvent, TypeTextEvent, UploadFileEvent, WaitEvent } from '../events.js';
+import { BaseWatchdog } from './base.js';
+export declare class DefaultActionWatchdog extends BaseWatchdog {
+    static LISTENS_TO: (typeof ClickElementEvent | typeof ClickCoordinateEvent | typeof TypeTextEvent | typeof SwitchTabEvent | typeof GoBackEvent | typeof GetDropdownOptionsEvent)[];
+    on_NavigateToUrlEvent(event: NavigateToUrlEvent): Promise<void>;
+    on_SwitchTabEvent(event: SwitchTabEvent): Promise<string | null | undefined>;
+    on_CloseTabEvent(event: CloseTabEvent): Promise<void>;
+    on_GoBackEvent(): Promise<void>;
+    on_GoForwardEvent(): Promise<void>;
+    on_RefreshEvent(): Promise<void>;
+    on_WaitEvent(event: WaitEvent): Promise<void>;
+    on_SendKeysEvent(event: SendKeysEvent): Promise<void>;
+    on_ScrollEvent(event: ScrollEvent): Promise<void>;
+    on_ScrollToTextEvent(event: ScrollToTextEvent): Promise<void>;
+    on_ClickElementEvent(event: ClickElementEvent): Promise<string | {
+        validation_error: string;
+    } | null>;
+    on_ClickCoordinateEvent(event: ClickCoordinateEvent): Promise<{
+        coordinate_x: number;
+        coordinate_y: number;
+    }>;
+    on_TypeTextEvent(event: TypeTextEvent): Promise<void>;
+    on_UploadFileEvent(event: UploadFileEvent): Promise<void>;
+    on_GetDropdownOptionsEvent(event: GetDropdownOptionsEvent): Promise<{
+        type: string;
+        options: string;
+        formatted_options: any;
+        message: any;
+        short_term_memory: any;
+        long_term_memory: string;
+    }>;
+    on_SelectDropdownOptionEvent(event: SelectDropdownOptionEvent): Promise<{
+        message: string;
+        short_term_memory: string;
+        long_term_memory: string;
+        matched_text: string;
+        matched_value: string;
+    } | {
+        message: string;
+        short_term_memory: string;
+        long_term_memory: string;
+        matched_text: string;
+        matched_value?: undefined;
+    }>;
+    private _isPrintRelatedElement;
+    private _handlePrintButtonClick;
+    private _getUniqueFilename;
+    private _sanitizeFilename;
+}

package/dist/browser/watchdogs/default-action-watchdog.js

@@ -0,0 +1,212 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { ClickCoordinateEvent, ClickElementEvent, CloseTabEvent, FileDownloadedEvent, GetDropdownOptionsEvent, GoBackEvent, GoForwardEvent, NavigateToUrlEvent, RefreshEvent, ScrollEvent, ScrollToTextEvent, SelectDropdownOptionEvent, SendKeysEvent, SwitchTabEvent, TypeTextEvent, UploadFileEvent, WaitEvent, } from '../events.js';
+import { BaseWatchdog } from './base.js';
+export class DefaultActionWatchdog extends BaseWatchdog {
+    static LISTENS_TO = [
+        NavigateToUrlEvent,
+        SwitchTabEvent,
+        CloseTabEvent,
+        GoBackEvent,
+        GoForwardEvent,
+        RefreshEvent,
+        WaitEvent,
+        SendKeysEvent,
+        ScrollEvent,
+        ScrollToTextEvent,
+        ClickElementEvent,
+        TypeTextEvent,
+        UploadFileEvent,
+        ClickCoordinateEvent,
+        GetDropdownOptionsEvent,
+        SelectDropdownOptionEvent,
+    ];
+    async on_NavigateToUrlEvent(event) {
+        if (event.new_tab) {
+            await this.browser_session.create_new_tab(event.url, {
+                wait_until: event.wait_until,
+                timeout_ms: event.timeout_ms,
+            });
+            return;
+        }
+        await this.browser_session.navigate_to(event.url, {
+            wait_until: event.wait_until,
+            timeout_ms: event.timeout_ms,
+        });
+    }
+    async on_SwitchTabEvent(event) {
+        let identifier;
+        if (event.target_id) {
+            identifier = event.target_id;
+        }
+        else {
+            const tabs = this.browser_session.tabs;
+            if (tabs.length === 0) {
+                await this.browser_session.create_new_tab('about:blank');
+                return (this.browser_session.active_tab?.target_id ??
+                    this.browser_session.active_tab?.tab_id ??
+                    'unknown_target');
+            }
+            const latestTab = tabs[tabs.length - 1];
+            identifier = latestTab.target_id ?? latestTab.tab_id ?? latestTab.page_id;
+        }
+        const page = await this.browser_session.switch_to_tab(identifier);
+        const activeTargetId = this.browser_session.active_tab?.target_id ?? null;
+        return (activeTargetId ?? (page ? this.browser_session.active_tab?.tab_id : null));
+    }
+    async on_CloseTabEvent(event) {
+        await this.browser_session.close_tab(event.target_id);
+    }
+    async on_GoBackEvent() {
+        await this.browser_session.go_back();
+    }
+    async on_GoForwardEvent() {
+        await this.browser_session.go_forward();
+    }
+    async on_RefreshEvent() {
+        await this.browser_session.refresh();
+    }
+    async on_WaitEvent(event) {
+        const seconds = Math.min(Math.max(event.seconds, 0), event.max_seconds);
+        await this.browser_session.wait(seconds);
+    }
+    async on_SendKeysEvent(event) {
+        await this.browser_session.send_keys(event.keys);
+    }
+    async on_ScrollEvent(event) {
+        await this.browser_session.scroll(event.direction, event.amount, {
+            node: event.node ?? null,
+        });
+    }
+    async on_ScrollToTextEvent(event) {
+        await this.browser_session.scroll_to_text(event.text, {
+            direction: event.direction,
+        });
+    }
+    async on_ClickElementEvent(event) {
+        if (this.browser_session.is_file_input(event.node)) {
+            return {
+                validation_error: 'The target element is a file input. Use upload_file action instead of click.',
+            };
+        }
+        if (this._isPrintRelatedElement(event.node)) {
+            const pdfPath = await this._handlePrintButtonClick();
+            if (pdfPath) {
+                return pdfPath;
+            }
+        }
+        return this.browser_session._click_element_node(event.node);
+    }
+    async on_ClickCoordinateEvent(event) {
+        await this.browser_session.click_coordinates(event.coordinate_x, event.coordinate_y, {
+            button: event.button,
+        });
+        return {
+            coordinate_x: event.coordinate_x,
+            coordinate_y: event.coordinate_y,
+        };
+    }
+    async on_TypeTextEvent(event) {
+        return this.browser_session._input_text_element_node(event.node, event.text, {
+            clear: event.clear,
+        });
+    }
+    async on_UploadFileEvent(event) {
+        await this.browser_session.upload_file(event.node, event.file_path);
+    }
+    async on_GetDropdownOptionsEvent(event) {
+        return this.browser_session.get_dropdown_options(event.node);
+    }
+    async on_SelectDropdownOptionEvent(event) {
+        return this.browser_session.select_dropdown_option(event.node, event.text);
+    }
+    _isPrintRelatedElement(node) {
+        if (!node || typeof node !== 'object') {
+            return false;
+        }
+        const attributes = 'attributes' in node && node.attributes
+            ? node.attributes
+            : {};
+        const onclick = String(attributes.onclick ?? '').toLowerCase();
+        if (onclick.includes('print')) {
+            return true;
+        }
+        const textMethods = [
+            node.get_all_text_till_next_clickable_element,
+            node.get_all_children_text,
+        ];
+        for (const textMethod of textMethods) {
+            if (typeof textMethod !== 'function') {
+                continue;
+            }
+            try {
+                const text = String(textMethod.call(node, 2) ?? '').toLowerCase();
+                if (text.includes('print')) {
+                    return true;
+                }
+            }
+            catch {
+                // Ignore text extraction failures.
+            }
+        }
+        return false;
+    }
+    async _handlePrintButtonClick() {
+        const page = await this.browser_session.get_current_page();
+        if (!page) {
+            return null;
+        }
+        try {
+            const cdpSession = await this.browser_session.get_or_create_cdp_session(page);
+            const result = await cdpSession.send?.('Page.printToPDF', {
+                printBackground: true,
+                preferCSSPageSize: true,
+            });
+            const pdfBase64 = result && typeof result.data === 'string' ? result.data : null;
+            if (!pdfBase64) {
+                return null;
+            }
+            const downloadsPath = this.browser_session.browser_profile.downloads_path || os.tmpdir();
+            fs.mkdirSync(downloadsPath, { recursive: true });
+            const title = typeof page.title === 'function' ? await page.title() : 'document';
+            const suggestedName = this._sanitizeFilename(`${title || 'document'}.pdf`);
+            const uniqueFilename = await this._getUniqueFilename(downloadsPath, suggestedName);
+            const finalPath = path.join(downloadsPath, uniqueFilename);
+            const content = Buffer.from(pdfBase64, 'base64');
+            fs.writeFileSync(finalPath, content);
+            await this.event_bus.dispatch(new FileDownloadedEvent({
+                guid: null,
+                url: typeof page.url === 'function' ? page.url() : '',
+                path: finalPath,
+                file_name: uniqueFilename,
+                file_size: content.length,
+                file_type: 'pdf',
+                mime_type: 'application/pdf',
+                auto_download: false,
+            }));
+            return finalPath;
+        }
+        catch (error) {
+            this.browser_session.logger.debug(`[DefaultActionWatchdog] Print-to-PDF failed: ${error.message}`);
+            return null;
+        }
+    }
+    async _getUniqueFilename(directory, filename) {
+        const parsed = path.parse(filename);
+        let candidate = filename;
+        let counter = 1;
+        while (fs.existsSync(path.join(directory, candidate))) {
+            candidate = `${parsed.name} (${counter})${parsed.ext}`;
+            counter += 1;
+        }
+        return candidate;
+    }
+    _sanitizeFilename(filename) {
+        const sanitized = filename
+            .replace(/[\\/:*?"<>|]+/g, '_')
+            .replace(/\s+/g, ' ')
+            .trim();
+        return sanitized || 'document.pdf';
+    }
+}

package/dist/browser/watchdogs/dom-watchdog.d.ts

@@ -0,0 +1,8 @@
+import { BrowserErrorEvent, BrowserStateRequestEvent, TabCreatedEvent } from '../events.js';
+import { BaseWatchdog } from './base.js';
+export declare class DOMWatchdog extends BaseWatchdog {
+    static LISTENS_TO: (typeof BrowserStateRequestEvent | typeof TabCreatedEvent)[];
+    static EMITS: (typeof BrowserErrorEvent)[];
+    on_TabCreatedEvent(): Promise<null>;
+    on_BrowserStateRequestEvent(event: BrowserStateRequestEvent): Promise<import("../views.js").BrowserStateSummary>;
+}

package/dist/browser/watchdogs/dom-watchdog.js

@@ -0,0 +1,31 @@
+import { BrowserErrorEvent, BrowserStateRequestEvent, TabCreatedEvent, } from '../events.js';
+import { BaseWatchdog } from './base.js';
+export class DOMWatchdog extends BaseWatchdog {
+    static LISTENS_TO = [TabCreatedEvent, BrowserStateRequestEvent];
+    static EMITS = [BrowserErrorEvent];
+    async on_TabCreatedEvent() {
+        // Placeholder hook kept for parity with Python watchdog lifecycle.
+        return null;
+    }
+    async on_BrowserStateRequestEvent(event) {
+        try {
+            return await this.browser_session.get_browser_state_with_recovery({
+                cache_clickable_elements_hashes: true,
+                include_screenshot: event.include_screenshot,
+                include_recent_events: event.include_recent_events,
+            });
+        }
+        catch (error) {
+            await this.event_bus.dispatch(new BrowserErrorEvent({
+                error_type: 'BrowserStateRequestFailed',
+                message: `DOM state request failed: ${error.message}`,
+                details: {
+                    include_screenshot: event.include_screenshot,
+                    include_recent_events: event.include_recent_events,
+                },
+                event_parent_id: event.event_id,
+            }));
+            throw error;
+        }
+    }
+}

package/dist/browser/watchdogs/downloads-watchdog.d.ts

@@ -0,0 +1,77 @@
+import { BrowserConnectedEvent, BrowserLaunchEvent, BrowserStateRequestEvent, BrowserStoppedEvent, DownloadProgressEvent, DownloadStartedEvent, FileDownloadedEvent, TabClosedEvent } from '../events.js';
+import { BaseWatchdog } from './base.js';
+type DownloadStartInfo = {
+    guid: string;
+    url: string;
+    suggested_filename: string;
+    auto_download: boolean;
+};
+type DownloadProgressInfo = {
+    guid: string;
+    received_bytes: number;
+    total_bytes: number;
+    state: string;
+};
+type DownloadCompleteInfo = {
+    guid: string | null;
+    url: string;
+    path: string;
+    file_name: string;
+    file_size: number;
+    file_type: string | null;
+    mime_type: string | null;
+    auto_download: boolean;
+};
+export declare class DownloadsWatchdog extends BaseWatchdog {
+    static LISTENS_TO: (typeof BrowserStateRequestEvent | typeof BrowserLaunchEvent | typeof BrowserConnectedEvent | typeof BrowserStoppedEvent | typeof TabClosedEvent | typeof DownloadStartedEvent | typeof DownloadProgressEvent | typeof FileDownloadedEvent)[];
+    static EMITS: (typeof DownloadStartedEvent | typeof DownloadProgressEvent | typeof FileDownloadedEvent)[];
+    private _activeDownloads;
+    private _downloadStartCallbacks;
+    private _downloadProgressCallbacks;
+    private _downloadCompleteCallbacks;
+    private _cdpSession;
+    private _cdpListeners;
+    private _networkDownloads;
+    private _detectedDownloadUrls;
+    on_BrowserConnectedEvent(): Promise<void>;
+    on_BrowserLaunchEvent(): void;
+    on_BrowserStateRequestEvent(event: BrowserStateRequestEvent): Promise<void>;
+    on_BrowserStoppedEvent(): void;
+    on_TabCreatedEvent(): null;
+    on_TabClosedEvent(): null;
+    on_NavigationCompleteEvent(): null;
+    on_DownloadStartedEvent(event: DownloadStartedEvent): void;
+    on_DownloadProgressEvent(event: DownloadProgressEvent): void;
+    on_FileDownloadedEvent(event: FileDownloadedEvent): string;
+    get_active_downloads(): {
+        url: string;
+        suggested_filename: string;
+        started_at: string;
+        received_bytes: number;
+        total_bytes: number;
+        state: string;
+        guid: string;
+    }[];
+    register_download_callbacks(on_start_or_options?: ((info: DownloadStartInfo) => void) | {
+        on_start?: ((info: DownloadStartInfo) => void) | null;
+        on_progress?: ((info: DownloadProgressInfo) => void) | null;
+        on_complete?: ((info: DownloadCompleteInfo) => void) | null;
+    } | null, on_progress?: ((info: DownloadProgressInfo) => void) | null, on_complete?: ((info: DownloadCompleteInfo) => void) | null): void;
+    unregister_download_callbacks(on_start_or_options?: ((info: DownloadStartInfo) => void) | {
+        on_start?: ((info: DownloadStartInfo) => void) | null;
+        on_progress?: ((info: DownloadProgressInfo) => void) | null;
+        on_complete?: ((info: DownloadCompleteInfo) => void) | null;
+    } | null, on_progress?: ((info: DownloadProgressInfo) => void) | null, on_complete?: ((info: DownloadCompleteInfo) => void) | null): void;
+    protected onDetached(): void;
+    private _normalizeCallbackRegistration;
+    private _startCdpDownloadMonitoring;
+    private _stopCdpDownloadMonitoring;
+    private _handleNetworkResponse;
+    private _handleNetworkLoadingFinished;
+    private _normalizeHeaders;
+    private _resolveSuggestedFilename;
+    private _sanitizeFilename;
+    private _inferFileType;
+    private _getUniqueFilename;
+}
+export {};