@bctrl/sdk 1.0.1 → 1.0.2

package/dist/workspaces/browser-runtime.js

@@ -1,1025 +0,0 @@
-import { getRemoteListenerBinding } from '../base/event-binding.js';
-import { CaptchaNamespace } from '../captcha/namespace.js';
-import { fromErrorResponse } from '../errors.js';
-import { CONTEXT_REF_TARGETS, HANDLE_TARGETS, PAGE_REF_TARGETS } from '../internal/rpc-targets.js';
-import { fetchWithTimeout, parseErrorDetails, parseJsonResponse } from '../utils/http.js';
-import { SDK_VERSION } from '../version.js';
-import { StagehandCore } from '../agents/stagehand/core.js';
-import { RemotePlaywrightBrowser } from '../drivers/playwright/generated/browser.js';
-import { RemotePlaywrightBrowserContext } from '../drivers/playwright/generated/browser-context.js';
-import { RemotePlaywrightElementHandle } from '../drivers/playwright/generated/element-handle.js';
-import { RemotePlaywrightFrame } from '../drivers/playwright/generated/frame.js';
-import { RemotePlaywrightFrameLocator } from '../drivers/playwright/generated/frame-locator.js';
-import { RemotePlaywrightJSHandle } from '../drivers/playwright/generated/js-handle.js';
-import { RemotePlaywrightLocator } from '../drivers/playwright/generated/locator.js';
-import { RemotePlaywrightPage } from '../drivers/playwright/generated/page.js';
-import { RemotePuppeteerBrowser } from '../drivers/puppeteer/generated/browser.js';
-import { RemotePuppeteerBrowserContext } from '../drivers/puppeteer/generated/browser-context.js';
-import { RemotePuppeteerElementHandle } from '../drivers/puppeteer/generated/element-handle.js';
-import { RemotePuppeteerFrame } from '../drivers/puppeteer/generated/frame.js';
-import { RemotePuppeteerJSHandle } from '../drivers/puppeteer/generated/js-handle.js';
-import { RemotePuppeteerLocator } from '../drivers/puppeteer/generated/locator.js';
-import { RemotePuppeteerPage } from '../drivers/puppeteer/generated/page.js';
-import { RemoteStagehandLocator } from '../drivers/stagehand/generated/locator.js';
-import { RemoteStagehandPage } from '../drivers/stagehand/generated/page.js';
-import { RemoteStagehandResponse } from '../drivers/stagehand/generated/response.js';
-import { RemoteWebDriver } from '../drivers/selenium/driver.js';
-import { RuntimeEventPump, } from './runtime-event-pump.js';
-const PLAYWRIGHT_PAGE_EVENT_MAP = {
-    console: 'console',
-    crash: 'page.crash',
-    dialog: 'page.dialog',
-    domcontentloaded: 'page.domcontentloaded',
-    download: 'page.download',
-    filechooser: 'page.filechooser',
-    frameattached: 'page.frame_attached',
-    framedetached: 'page.frame_detached',
-    framenavigated: 'page.navigated',
-    load: 'page.load',
-    popup: 'page.popup',
-    request: 'page.request',
-    pageerror: 'page.error',
-    requestfinished: 'page.request_finished',
-    requestfailed: 'page.request_failed',
-    response: 'page.response',
-    websocket: 'page.websocket',
-    worker: 'page.worker',
-    close: 'page.closed',
-};
-const PLAYWRIGHT_CONTEXT_EVENT_MAP = {
-    page: 'context.page_created',
-    close: 'context.closed',
-};
-const PUPPETEER_PAGE_EVENT_MAP = {
-    close: 'page.closed',
-    console: 'console',
-    dialog: 'page.dialog',
-    domcontentloaded: 'page.domcontentloaded',
-    error: 'page.crash',
-    frameattached: 'page.frame_attached',
-    framedetached: 'page.frame_detached',
-    framenavigated: 'page.navigated',
-    load: 'page.load',
-    pageerror: 'page.error',
-    popup: 'page.popup',
-    request: 'page.request',
-    requestfailed: 'page.request_failed',
-    requestfinished: 'page.request_finished',
-    response: 'page.response',
-    workercreated: 'page.worker',
-};
-const STAGEHAND_PAGE_EVENT_MAP = {
-    ...PLAYWRIGHT_PAGE_EVENT_MAP,
-};
-function getTimeoutMs(timeoutRaw, fallbackMs) {
-    return typeof timeoutRaw === 'number' && Number.isFinite(timeoutRaw)
-        ? Math.max(0, Math.floor(timeoutRaw))
-        : fallbackMs;
-}
-function patchLocalWaitForEvent(target, options) {
-    if (target[options.patchedFlag])
-        return;
-    target[options.patchedFlag] = true;
-    const originalWaitForEvent = typeof target.waitForEvent === 'function' ? target.waitForEvent.bind(target) : null;
-    target.waitForEvent = async (event, optionsOrPredicate) => {
-        const eventName = String(event);
-        if (originalWaitForEvent &&
-            options.supportedEvents &&
-            !options.supportedEvents.has(eventName)) {
-            return originalWaitForEvent(eventName, optionsOrPredicate);
-        }
-        const predicate = typeof optionsOrPredicate === 'function'
-            ? optionsOrPredicate
-            : typeof optionsOrPredicate?.predicate === 'function'
-                ? optionsOrPredicate.predicate
-                : undefined;
-        const timeoutRaw = typeof optionsOrPredicate === 'object' && optionsOrPredicate
-            ? optionsOrPredicate.timeout
-            : undefined;
-        const timeoutMs = getTimeoutMs(timeoutRaw, options.defaultTimeoutMs());
-        return new Promise((resolve, reject) => {
-            let done = false;
-            let timeoutId = null;
-            const cleanup = () => {
-                target.off(eventName, handler);
-                if (timeoutId) {
-                    clearTimeout(timeoutId);
-                    timeoutId = null;
-                }
-            };
-            const handler = (value) => {
-                if (done)
-                    return;
-                void (async () => {
-                    try {
-                        if (predicate) {
-                            const matched = await predicate(value);
-                            if (!matched)
-                                return;
-                        }
-                        done = true;
-                        cleanup();
-                        resolve(value);
-                    }
-                    catch (error) {
-                        done = true;
-                        cleanup();
-                        reject(error);
-                    }
-                })();
-            };
-            target.on(eventName, handler);
-            if (timeoutMs > 0) {
-                timeoutId = setTimeout(() => {
-                    if (done)
-                        return;
-                    done = true;
-                    cleanup();
-                    reject(new Error(`waitForEvent('${eventName}') timed out after ${timeoutMs}ms`));
-                }, timeoutMs);
-            }
-        });
-    };
-}
-function patchStagehandEventBridge(page) {
-    const target = page;
-    const record = page;
-    const getListeners = () => {
-        const value = record['_eventListeners'];
-        return value instanceof Map
-            ? value
-            : new Map();
-    };
-    if (!record['__bctrlEventBridgePatched']) {
-        record['__bctrlEventBridgePatched'] = true;
-        const originalOn = target.on.bind(page);
-        const originalOff = target.off.bind(page);
-        target.listenerCount = (event) => {
-            return getListeners().get(event)?.size ?? 0;
-        };
-        target.emit = (event, payload) => {
-            const listeners = Array.from(getListeners().get(event) ?? []);
-            if (listeners.length === 0)
-                return false;
-            for (const handler of listeners) {
-                try {
-                    handler(payload);
-                }
-                catch (error) {
-                    console.error(`Error in Stagehand event handler for "${event}":`, error);
-                }
-            }
-            return true;
-        };
-        target.on = ((event, handler) => {
-            const hadListeners = target.listenerCount?.(event) ?? 0;
-            const result = originalOn(event, handler);
-            const hasListeners = (target.listenerCount?.(event) ?? 0) > 0;
-            if (hadListeners === 0 && hasListeners) {
-                getRemoteListenerBinding(page)?.onFirstListener(event);
-            }
-            return result;
-        });
-        target.off = ((event, handler) => {
-            const hadListeners = (target.listenerCount?.(event) ?? 0) > 0;
-            const result = originalOff(event, handler);
-            const hasListeners = (target.listenerCount?.(event) ?? 0) > 0;
-            if (hadListeners && !hasListeners) {
-                getRemoteListenerBinding(page)?.onNoListeners(event);
-            }
-            return result;
-        });
-    }
-    patchLocalWaitForEvent(record, {
-        patchedFlag: '__bctrlWaitForEventPatched',
-        defaultTimeoutMs: () => 30_000,
-    });
-    return target;
-}
-function buildHeaders(apiKey, withJsonBody = false) {
-    const headers = {
-        'x-sdk-version': SDK_VERSION,
-        Authorization: `Bearer ${apiKey}`,
-    };
-    if (withJsonBody) {
-        headers['Content-Type'] = 'application/json';
-    }
-    return headers;
-}
-async function expectJson(response, context) {
-    if (!response.ok) {
-        const details = parseErrorDetails(await response.text());
-        throw new Error(`${context}: ${details.message}`);
-    }
-    return parseJsonResponse(response, context);
-}
-class RuntimeExecutionTransport {
-    workspaceClient;
-    runtimeAlias;
-    contextId;
-    activePageId;
-    constructor(workspaceClient, runtimeAlias, runtime) {
-        this.workspaceClient = workspaceClient;
-        this.runtimeAlias = runtimeAlias;
-        this.contextId = runtime?.summary?.defaultContextId ?? undefined;
-        this.activePageId = runtime?.summary?.defaultPageId ?? undefined;
-    }
-    getContextId() {
-        return this.contextId;
-    }
-    getActivePageId() {
-        return this.activePageId;
-    }
-    noteContext(contextId) {
-        if (contextId) {
-            this.contextId = contextId;
-        }
-    }
-    notePage(pageId, contextId) {
-        if (contextId) {
-            this.contextId = contextId;
-        }
-        if (pageId) {
-            this.activePageId = pageId;
-        }
-    }
-    buildRef(target, ids) {
-        if (HANDLE_TARGETS.has(target)) {
-            return ids?.handleId;
-        }
-        if (CONTEXT_REF_TARGETS.has(target)) {
-            return ids?.contextId;
-        }
-        if (PAGE_REF_TARGETS.has(target)) {
-            return ids?.pageId;
-        }
-        return undefined;
-    }
-    rememberCallResult(call, step) {
-        if (step.resolved.contextId) {
-            this.contextId = step.resolved.contextId;
-        }
-        if (step.resolved.pageId) {
-            this.activePageId = step.resolved.pageId;
-        }
-        if (step.binding?.type === 'context') {
-            this.contextId = step.binding.id;
-        }
-        if (step.binding?.type === 'page') {
-            this.activePageId = step.binding.id;
-        }
-        if (typeof step.result === 'string') {
-            if (call === 'browser.newContext') {
-                this.contextId = step.result;
-            }
-            if (call === 'browser.newPage' || call === 'context.newPage' || call === 'stagehand.context.newPage') {
-                this.activePageId = step.result;
-            }
-        }
-    }
-    async executeSingleStep(step) {
-        return this.workspaceClient.execute({
-            runtime: this.runtimeAlias,
-            steps: [step],
-        });
-    }
-    async executeImmediate(call, args = [], ids, options) {
-        const target = call.slice(0, call.indexOf('.'));
-        const ref = this.buildRef(target, ids);
-        const response = await this.executeSingleStep({
-            call,
-            ...(ref ? { ref } : {}),
-            ...(args.length > 0 ? { args } : {}),
-            ...(options ? { options } : {}),
-        });
-        if (response.kind === 'operation') {
-            throw new Error(`Call '${call}' started a long-running operation; use runtime.run() or the agent APIs for operation-aware execution.`);
-        }
-        const step = response.result.steps[0];
-        if (!step.ok) {
-            throw fromErrorResponse(step.error.message, step.error.code, {
-                ...(step.error.hint ? { hint: step.error.hint } : {}),
-                ...(step.error.diagnostic ? { diagnostic: step.error.diagnostic } : {}),
-            });
-        }
-        this.rememberCallResult(call, step);
-        return step.result;
-    }
-    async executeOperationAware(call, args = [], ids, options) {
-        const target = call.slice(0, call.indexOf('.'));
-        const ref = this.buildRef(target, ids);
-        const response = await this.executeSingleStep({
-            call,
-            ...(ref ? { ref } : {}),
-            ...(args.length > 0 ? { args } : {}),
-            ...(options ? { options } : {}),
-        });
-        if (response.kind === 'result') {
-            const step = response.result.steps[0];
-            if (!step.ok) {
-                throw fromErrorResponse(step.error.message, step.error.code, {
-                    ...(step.error.hint ? { hint: step.error.hint } : {}),
-                    ...(step.error.diagnostic ? { diagnostic: step.error.diagnostic } : {}),
-                });
-            }
-            this.rememberCallResult(call, step);
-        }
-        return response;
-    }
-    createRpcSender() {
-        return (target, method, args, ids) => {
-            return this.executeImmediate(`${target}.${method}`, args, ids);
-        };
-    }
-    createPageSender(pageId, contextId) {
-        return async (method, args) => {
-            this.notePage(pageId, contextId);
-            return this.executeImmediate('page.' + method, args, { pageId, contextId });
-        };
-    }
-    createContextSender(contextId) {
-        return async (method, args) => {
-            this.noteContext(contextId);
-            return this.executeImmediate('context.' + method, args, { contextId });
-        };
-    }
-    createBrowserSender() {
-        return async (method, args) => {
-            return this.executeImmediate('browser.' + method, args);
-        };
-    }
-    createHandleSender(target, handleId) {
-        return async (method, args) => {
-            return this.executeImmediate(`${target}.${method}`, args, { handleId });
-        };
-    }
-    createLocatorSender(selector, pageId, contextId) {
-        return async (method, args) => {
-            const cleanMethod = method.startsWith('locator:') ? method.slice(8) : method;
-            this.notePage(pageId, contextId);
-            return this.executeImmediate('locator.' + cleanMethod, [selector, ...args], { pageId, contextId });
-        };
-    }
-}
-class BrowserRuntimeEventsClient {
-    workspaceClient;
-    runtimeAlias;
-    constructor(workspaceClient, runtimeAlias) {
-        this.workspaceClient = workspaceClient;
-        this.runtimeAlias = runtimeAlias;
-    }
-    async list(query = {}) {
-        const params = new URLSearchParams();
-        if (query.after)
-            params.set('after', query.after);
-        if (query.limit !== undefined)
-            params.set('limit', String(query.limit));
-        if (query.pageId)
-            params.set('pageId', query.pageId);
-        if (query.contextId)
-            params.set('contextId', query.contextId);
-        if (Array.isArray(query.eventTypes)) {
-            for (const eventType of query.eventTypes)
-                params.append('eventTypes', eventType);
-        }
-        else if (typeof query.eventTypes === 'string') {
-            params.set('eventTypes', query.eventTypes);
-        }
-        const suffix = params.toString() ? `?${params.toString()}` : '';
-        const response = await fetchWithTimeout(`${this.workspaceClient.baseUrl}/workspaces/${encodeURIComponent(this.workspaceClient.id)}/runtimes/${encodeURIComponent(this.runtimeAlias)}/events${suffix}`, { headers: buildHeaders(this.workspaceClient.apiKey) });
-        return expectJson(response, 'List runtime events');
-    }
-    async wait(request = {}, options = {}) {
-        const controller = new AbortController();
-        const timeoutMs = (request.timeoutMs ?? 30_000) + 5_000;
-        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-        const onAbort = () => controller.abort();
-        if (options.signal) {
-            if (options.signal.aborted) {
-                controller.abort();
-            }
-            else {
-                options.signal.addEventListener('abort', onAbort, { once: true });
-            }
-        }
-        let response;
-        try {
-            response = await fetch(`${this.workspaceClient.baseUrl}/workspaces/${encodeURIComponent(this.workspaceClient.id)}/runtimes/${encodeURIComponent(this.runtimeAlias)}/events/wait`, {
-                method: 'POST',
-                headers: buildHeaders(this.workspaceClient.apiKey, true),
-                body: JSON.stringify(request),
-                signal: controller.signal,
-            });
-        }
-        finally {
-            clearTimeout(timeoutId);
-            options.signal?.removeEventListener('abort', onAbort);
-        }
-        return expectJson(response, 'Wait for runtime event');
-    }
-}
-export class BrowserRuntimeAccessor {
-    workspaceClient;
-    runtimeAlias;
-    events;
-    constructor(workspaceClient, runtimeAlias) {
-        this.workspaceClient = workspaceClient;
-        this.runtimeAlias = runtimeAlias;
-        this.events = new BrowserRuntimeEventsClient(workspaceClient, runtimeAlias);
-    }
-    async run(input) {
-        return this.workspaceClient.execute({
-            runtime: this.runtimeAlias,
-            ...(input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}),
-            mode: input.mode,
-            steps: input.steps,
-        });
-    }
-    async state() {
-        return this.workspaceClient.state({ runtime: this.runtimeAlias });
-    }
-    async help(topic) {
-        return this.workspaceClient.help({
-            runtime: this.runtimeAlias,
-            ...(topic ? { topic } : {}),
-        });
-    }
-    async live(options = {}) {
-        return this.workspaceClient.embedRuntimeLive(this.runtimeAlias, options);
-    }
-    async recording() {
-        return this.workspaceClient.embedRuntimeRecording(this.runtimeAlias);
-    }
-    async stop() {
-        return this.workspaceClient.stopRuntime(this.runtimeAlias);
-    }
-}
-export class BrowserRuntimeClient extends BrowserRuntimeAccessor {
-    runtimeValue;
-    transport;
-    eventPump = null;
-    _captcha = null;
-    constructor(workspaceClient, runtimeValue) {
-        super(workspaceClient, runtimeValue.alias);
-        this.runtimeValue = runtimeValue;
-        this.transport = new RuntimeExecutionTransport(workspaceClient, runtimeValue.alias, runtimeValue);
-    }
-    get id() {
-        return this.runtimeValue.id;
-    }
-    get alias() {
-        return this.runtimeValue.alias;
-    }
-    get driverName() {
-        return this.runtimeValue.driver;
-    }
-    get status() {
-        return this.runtimeValue.status;
-    }
-    get captcha() {
-        if (!this._captcha) {
-            this._captcha = new CaptchaNamespace(this.transport.createRpcSender(), () => this.transport.getActivePageId());
-        }
-        return this._captcha;
-    }
-    getEventPump() {
-        if (!this.eventPump) {
-            this.eventPump = new RuntimeEventPump(this.events);
-        }
-        return this.eventPump;
-    }
-    registerPageEventEmitter(registration) {
-        this.getEventPump().registerPageEmitter(registration);
-    }
-    registerContextEventEmitter(registration) {
-        this.getEventPump().registerContextEmitter(registration);
-    }
-    async stop() {
-        if (this.eventPump) {
-            await this.eventPump.close();
-            this.eventPump = null;
-        }
-        const runtime = await super.stop();
-        this.runtimeValue = runtime;
-        return runtime;
-    }
-}
-class RuntimeStagehandAgent {
-    transport;
-    getContextId;
-    resolvePageId;
-    config;
-    constructor(transport, getContextId, resolvePageId, config) {
-        this.transport = transport;
-        this.getContextId = getContextId;
-        this.resolvePageId = resolvePageId;
-        this.config = config;
-    }
-    execute(instructionOrOptions, options) {
-        const isString = typeof instructionOrOptions === 'string';
-        const page = isString ? options?.page : instructionOrOptions.page;
-        let cleanOptions;
-        if (isString) {
-            const { page: _page, ...rest } = options ?? {};
-            cleanOptions = {
-                instruction: instructionOrOptions,
-                ...rest,
-            };
-        }
-        else {
-            const { page: _page, ...rest } = instructionOrOptions;
-            cleanOptions = rest;
-        }
-        return this.transport.executeOperationAware('stagehand.agent.execute', [this.config, cleanOptions], {
-            contextId: this.getContextId(),
-            pageId: this.resolvePageId(page),
-        });
-    }
-}
-class RuntimeStagehandNamespace {
-    transport;
-    getContextId;
-    getActivePageId;
-    resolvePage;
-    core;
-    constructor(transport, getContextId, getActivePageId, resolvePage) {
-        this.transport = transport;
-        this.getContextId = getContextId;
-        this.getActivePageId = getActivePageId;
-        this.resolvePage = resolvePage;
-        this.core = new StagehandCore(transport.createRpcSender(), getContextId, getActivePageId, resolvePage);
-    }
-    act(instruction, options) {
-        return this.core.act(instruction, options);
-    }
-    extract(instructionOrOptions, schema, options) {
-        return this.core.extract(instructionOrOptions, schema, options);
-    }
-    observe(instructionOrOptions, options) {
-        return this.core.observe(instructionOrOptions, options);
-    }
-    agent(config) {
-        return new RuntimeStagehandAgent(this.transport, this.getContextId, (page) => {
-            if (page) {
-                const resolved = this.resolvePage(page);
-                if (resolved)
-                    return resolved;
-            }
-            return this.getActivePageId();
-        }, config);
-    }
-    getMetrics() {
-        return this.core.getMetrics();
-    }
-    getHistory() {
-        return this.core.getHistory();
-    }
-}
-class RuntimeBrowserUseNamespace {
-    transport;
-    getActivePageId;
-    constructor(transport, getActivePageId) {
-        this.transport = transport;
-        this.getActivePageId = getActivePageId;
-    }
-    agent(config = {}) {
-        return {
-            execute: async (task, options) => {
-                const pageId = config.pageId || this.getActivePageId();
-                const executeOptions = {
-                    task,
-                    ...(options?.maxSteps !== undefined ? { maxSteps: options.maxSteps } : {}),
-                    ...(options?.tools !== undefined ? { tools: options.tools } : {}),
-                };
-                return this.transport.executeOperationAware('browserUse.agent.execute', [config, executeOptions], { pageId });
-            },
-        };
-    }
-    codeAgent(config = {}) {
-        return {
-            execute: async (task, options) => {
-                const pageId = config.pageId || this.getActivePageId();
-                const executeOptions = {
-                    task,
-                    ...(options?.maxSteps !== undefined ? { maxSteps: options.maxSteps } : {}),
-                    ...(options?.tools !== undefined ? { tools: options.tools } : {}),
-                };
-                return this.transport.executeOperationAware('browserUse.codeAgent.execute', [config, executeOptions], { pageId });
-            },
-        };
-    }
-}
-class AgentBrowserRuntimeClient extends BrowserRuntimeClient {
-    _stagehand = null;
-    _browserUse = null;
-    get stagehand() {
-        if (!this._stagehand) {
-            this._stagehand = new RuntimeStagehandNamespace(this.transport, () => this.transport.getContextId(), () => this.transport.getActivePageId(), (page) => this.resolvePage(page));
-        }
-        return this._stagehand;
-    }
-    get browserUse() {
-        if (!this._browserUse) {
-            this._browserUse = new RuntimeBrowserUseNamespace(this.transport, () => this.transport.getActivePageId());
-        }
-        return this._browserUse;
-    }
-}
-export class PlaywrightBrowserRuntimeClient extends AgentBrowserRuntimeClient {
-    _browser = null;
-    _defaultPage = null;
-    contextCache = new Map();
-    pageCache = new Map();
-    pageContextIds = new Map();
-    resolvePage(page) {
-        return page instanceof RemotePlaywrightPage ? page.id : undefined;
-    }
-    get browser() {
-        if (!this._browser) {
-            this._browser = new RemotePlaywrightBrowser('default', this.transport.createBrowserSender(), (contextId) => this.getOrCreateBrowserContext(contextId), (pageId) => this.createPlaywrightPage(pageId, this.transport.getContextId()));
-        }
-        return this._browser;
-    }
-    get browserContext() {
-        const contextId = this.transport.getContextId();
-        if (!contextId) {
-            throw new Error('No default browser context available');
-        }
-        return this.getOrCreateBrowserContext(contextId);
-    }
-    get page() {
-        if (!this._defaultPage) {
-            const pageId = this.transport.getActivePageId();
-            if (!pageId) {
-                throw new Error('No default page available');
-            }
-            this._defaultPage = this.createPlaywrightPage(pageId, this.transport.getContextId());
-        }
-        return this._defaultPage;
-    }
-    async getPages() {
-        return this.browserContext.pages();
-    }
-    resolvePageContextId(pageId, contextId) {
-        if (contextId) {
-            this.pageContextIds.set(pageId, contextId);
-            return contextId;
-        }
-        return this.pageContextIds.get(pageId) ?? this.transport.getContextId();
-    }
-    getOrCreateBrowserContext(contextId) {
-        const cached = this.contextCache.get(contextId);
-        if (cached)
-            return cached;
-        this.transport.noteContext(contextId);
-        const context = new RemotePlaywrightBrowserContext(contextId, this.transport.createContextSender(contextId), (pageId) => this.createPlaywrightPage(pageId, contextId), this._browser);
-        patchLocalWaitForEvent(context, {
-            patchedFlag: '__bctrlWaitForContextEventPatched',
-            supportedEvents: new Set(Object.keys(PLAYWRIGHT_CONTEXT_EVENT_MAP)),
-            defaultTimeoutMs: () => getTimeoutMs(context._defaultTimeout, 30_000),
-        });
-        this.registerContextEventEmitter({
-            contextId,
-            emitter: context,
-            eventMap: PLAYWRIGHT_CONTEXT_EVENT_MAP,
-            createPage: (pageId) => this.createPlaywrightPage(pageId, contextId),
-        });
-        this.contextCache.set(contextId, context);
-        return context;
-    }
-    createPlaywrightPage(pageId, contextId) {
-        this.transport.notePage(pageId, contextId);
-        this.resolvePageContextId(pageId, contextId);
-        const cached = this.pageCache.get(pageId);
-        if (cached)
-            return cached;
-        let page;
-        const frameCache = new Map();
-        const contextIdForPage = () => this.resolvePageContextId(pageId, contextId);
-        const pageRpcSender = this.transport.createPageSender(pageId, contextIdForPage());
-        const createFrameRpcSender = (handleId) => this.transport.createHandleSender('frame', handleId);
-        const createJSHandleRpcSender = (handleId) => this.transport.createHandleSender('jsHandle', handleId);
-        const createElementRpcSender = (handleId) => this.transport.createHandleSender('element', handleId);
-        const createLocatorRpcSender = (selector) => this.transport.createLocatorSender(selector, pageId, contextIdForPage());
-        const createJSHandle = (handleId) => new RemotePlaywrightJSHandle(handleId, createJSHandleRpcSender(handleId), createJSHandle);
-        const createElementHandle = (handleId) => new RemotePlaywrightElementHandle(handleId, createElementRpcSender(handleId), createElementHandle, createFrame, createJSHandle);
-        const createFrameLocator = (selector) => new RemotePlaywrightFrameLocator(pageRpcSender, selector, createLocator);
-        const createLocator = (selector) => new RemotePlaywrightLocator(selector, createLocatorRpcSender(selector), createElementHandle, createLocator, createFrameLocator, page);
-        const createFrame = (frameId) => {
-            let frame = frameCache.get(frameId);
-            if (!frame) {
-                frame = new RemotePlaywrightFrame(frameId, createFrameRpcSender(frameId), createElementHandle, createFrame, createLocator, createFrameLocator, createJSHandle, () => page);
-                frameCache.set(frameId, frame);
-            }
-            return frame;
-        };
-        page = new RemotePlaywrightPage(pageRpcSender, pageId, createElementHandle, createFrame, createLocator, createJSHandle);
-        patchLocalWaitForEvent(page, {
-            patchedFlag: '__bctrlWaitForEventPatched',
-            supportedEvents: new Set(Object.keys(PLAYWRIGHT_PAGE_EVENT_MAP)),
-            defaultTimeoutMs: () => getTimeoutMs(page._defaultTimeout, 30_000),
-        });
-        this.registerPageEventEmitter({
-            pageId,
-            emitter: page,
-            eventMap: PLAYWRIGHT_PAGE_EVENT_MAP,
-            createPage: (nextPageId) => this.createPlaywrightPage(nextPageId, contextIdForPage()),
-        });
-        this.pageCache.set(pageId, page);
-        return page;
-    }
-}
-export class PuppeteerBrowserRuntimeClient extends AgentBrowserRuntimeClient {
-    _browser = null;
-    _defaultPage = null;
-    contextCache = new Map();
-    pageCache = new Map();
-    resolvePage(page) {
-        return page instanceof RemotePuppeteerPage ? page.id : undefined;
-    }
-    get browser() {
-        if (!this._browser) {
-            const createContext = (contextId, isDefault) => {
-                return this.getOrCreateBrowserContext(contextId, isDefault);
-            };
-            this._browser = new RemotePuppeteerBrowser(this.transport.createBrowserSender(), (pageId) => this.createPuppeteerPage(pageId), createContext);
-        }
-        return this._browser;
-    }
-    get page() {
-        if (!this._defaultPage) {
-            const pageId = this.transport.getActivePageId();
-            if (!pageId) {
-                throw new Error('No default page available');
-            }
-            this._defaultPage = this.createPuppeteerPage(pageId);
-        }
-        return this._defaultPage;
-    }
-    getOrCreateBrowserContext(contextId, isDefault) {
-        const cached = this.contextCache.get(contextId);
-        if (cached)
-            return cached;
-        const contextRpcSender = async (method, args) => {
-            this.transport.noteContext(contextId);
-            return this.transport.executeImmediate('context.' + method, args, { contextId });
-        };
-        const context = new RemotePuppeteerBrowserContext(contextRpcSender, { contextId, isDefault }, (pageId) => this.createPuppeteerPage(pageId));
-        this.contextCache.set(contextId, context);
-        return context;
-    }
-    createPuppeteerPage(pageId) {
-        this.transport.notePage(pageId, this.transport.getContextId());
-        const cached = this.pageCache.get(pageId);
-        if (cached)
-            return cached;
-        let page;
-        const frameCache = new Map();
-        const contextId = this.transport.getContextId();
-        const pageTimeoutIds = { contextId, pageId };
-        let pageDefaultsInitPromise = null;
-        const ensurePageDefaults = async () => {
-            if (!pageDefaultsInitPromise) {
-                pageDefaultsInitPromise = (async () => {
-                    const defaultTimeoutMs = 120_000;
-                    try {
-                        await this.transport.executeImmediate('page.setDefaultTimeout', [defaultTimeoutMs], pageTimeoutIds);
-                        await this.transport.executeImmediate('page.setDefaultNavigationTimeout', [defaultTimeoutMs], pageTimeoutIds);
-                    }
-                    catch {
-                        // Fall back to upstream defaults.
-                    }
-                })();
-            }
-            await pageDefaultsInitPromise;
-        };
-        const pageRpcSender = async (method, args) => {
-            if (method !== 'setDefaultTimeout' && method !== 'setDefaultNavigationTimeout') {
-                await ensurePageDefaults();
-            }
-            this.transport.notePage(pageId, contextId);
-            return this.transport.executeImmediate('page.' + method, args, pageTimeoutIds);
-        };
-        const createFrameRpcSender = (frameId) => async (method, args) => {
-            await ensurePageDefaults();
-            return this.transport.executeImmediate('frame.' + method, args, {
-                contextId,
-                pageId,
-                handleId: frameId,
-            });
-        };
-        const createElementRpcSender = (handleId) => async (method, args) => {
-            await ensurePageDefaults();
-            return this.transport.executeImmediate('element.' + method, args, {
-                contextId,
-                pageId,
-                handleId,
-            });
-        };
-        const createJSHandleRpcSender = (handleId) => async (method, args) => {
-            await ensurePageDefaults();
-            return this.transport.executeImmediate('jsHandle.' + method, args, {
-                contextId,
-                pageId,
-                handleId,
-            });
-        };
-        const createLocatorRpcSender = (selector) => async (method, args) => {
-            await ensurePageDefaults();
-            const cleanMethod = method.startsWith('locator:') ? method.slice(8) : method;
-            return this.transport.executeImmediate('locator.' + cleanMethod, [selector, ...args], {
-                contextId,
-                pageId,
-            });
-        };
-        const createTouchHandle = (touchId) => ({
-            move: async (x, y) => {
-                await pageRpcSender('touchscreen.touchMove', [touchId, x, y]);
-            },
-            end: async () => {
-                await pageRpcSender('touchscreen.touchEnd', [touchId]);
-            },
-        });
-        const createLocator = (selector) => new RemotePuppeteerLocator(selector, createLocatorRpcSender(selector), createElementHandle, createLocator);
-        const createFrame = (frameId) => {
-            let frame = frameCache.get(frameId);
-            if (!frame) {
-                frame = new RemotePuppeteerFrame(frameId, createFrameRpcSender(frameId), createElementHandle, createFrame, createLocator, createJSHandle, () => page);
-                frameCache.set(frameId, frame);
-            }
-            return frame;
-        };
-        const createElementHandle = (handleId) => new RemotePuppeteerElementHandle(handleId, createElementRpcSender(handleId), createElementHandle, createFrame, createLocator, createTouchHandle);
-        const createJSHandle = (handleId) => new RemotePuppeteerJSHandle(handleId, createJSHandleRpcSender(handleId), createJSHandle, createElementHandle);
-        page = new RemotePuppeteerPage(pageRpcSender, pageId, createElementHandle, createFrame, createLocator, createJSHandle);
-        patchLocalWaitForEvent(page, {
-            patchedFlag: '__bctrlWaitForEventPatched',
-            supportedEvents: new Set(Object.keys(PUPPETEER_PAGE_EVENT_MAP)),
-            defaultTimeoutMs: () => getTimeoutMs(page.getDefaultTimeout?.(), 30_000),
-        });
-        this.registerPageEventEmitter({
-            pageId,
-            emitter: page,
-            eventMap: PUPPETEER_PAGE_EVENT_MAP,
-            callDialogAction: async (dialogId, action, promptText) => {
-                if (action === 'accept') {
-                    await this.transport.executeImmediate('dialog.accept', [promptText], {
-                        contextId,
-                        pageId,
-                        handleId: dialogId,
-                    });
-                    return;
-                }
-                await this.transport.executeImmediate('dialog.dismiss', [], {
-                    contextId,
-                    pageId,
-                    handleId: dialogId,
-                });
-            },
-        });
-        this.pageCache.set(pageId, page);
-        return page;
-    }
-}
-export class StagehandBrowserRuntimeClient extends AgentBrowserRuntimeClient {
-    _page = null;
-    pageCache = new Map();
-    resolvePage(page) {
-        return page instanceof RemoteStagehandPage ? page.id : undefined;
-    }
-    get page() {
-        if (!this._page) {
-            const pageId = this.transport.getActivePageId();
-            if (!pageId) {
-                throw new Error('No page available');
-            }
-            this._page = this.createStagehandPage(pageId);
-        }
-        return this._page;
-    }
-    createStagehandPage(pageId) {
-        this.transport.notePage(pageId, this.transport.getContextId());
-        const cached = this.pageCache.get(pageId);
-        if (cached)
-            return cached;
-        const pageRpcSender = this.transport.createPageSender(pageId, this.transport.getContextId());
-        const createLocator = (selector) => new RemoteStagehandLocator(selector, async (method, args) => {
-            return this.transport.executeImmediate('locator.' + method, [selector, ...args], {
-                pageId,
-                contextId: this.transport.getContextId(),
-            });
-        });
-        const createResponse = (data) => new RemoteStagehandResponse(pageRpcSender, data);
-        const page = patchStagehandEventBridge(new RemoteStagehandPage(pageId, pageRpcSender, createLocator, createLocator, createResponse));
-        this.registerPageEventEmitter({
-            pageId,
-            emitter: page,
-            eventMap: STAGEHAND_PAGE_EVENT_MAP,
-            createPage: (nextPageId) => this.createStagehandPage(nextPageId),
-        });
-        this.pageCache.set(pageId, page);
-        return page;
-    }
-}
-export class SeleniumBrowserRuntimeClient extends AgentBrowserRuntimeClient {
-    _webDriver = null;
-    resolvePage() {
-        return undefined;
-    }
-    get webDriver() {
-        if (!this._webDriver) {
-            const pageId = this.transport.getActivePageId();
-            if (!pageId) {
-                throw new Error('No page available - runtime may not be initialized');
-            }
-            this._webDriver = new RemoteWebDriver(pageId, this.transport.createRpcSender());
-        }
-        return this._webDriver;
-    }
-    get driver() {
-        return this.webDriver;
-    }
-}
-export function createBrowserRuntimeClient(workspaceClient, runtime) {
-    switch (runtime.driver) {
-        case 'playwright':
-            return new PlaywrightBrowserRuntimeClient(workspaceClient, runtime);
-        case 'puppeteer':
-            return new PuppeteerBrowserRuntimeClient(workspaceClient, runtime);
-        case 'stagehand':
-            return new StagehandBrowserRuntimeClient(workspaceClient, runtime);
-        case 'selenium':
-            return new SeleniumBrowserRuntimeClient(workspaceClient, runtime);
-        default:
-            return new BrowserRuntimeClient(workspaceClient, runtime);
-    }
-}
-function createBrowserRuntimeClientForDriver(workspaceClient, runtime, driver) {
-    if (runtime.driver !== driver) {
-        throw new Error(`Expected runtime driver '${driver}', received '${runtime.driver}'`);
-    }
-    switch (driver) {
-        case 'playwright':
-            return new PlaywrightBrowserRuntimeClient(workspaceClient, runtime);
-        case 'puppeteer':
-            return new PuppeteerBrowserRuntimeClient(workspaceClient, runtime);
-        case 'stagehand':
-            return new StagehandBrowserRuntimeClient(workspaceClient, runtime);
-        case 'selenium':
-            return new SeleniumBrowserRuntimeClient(workspaceClient, runtime);
-    }
-}
-export class BrowserRuntimeBuilder extends BrowserRuntimeAccessor {
-    alias;
-    constructor(workspaceClient, alias) {
-        super(workspaceClient, alias);
-        this.alias = alias;
-    }
-    async createRuntimeRecord(driver, launch) {
-        return this.workspaceClient.createBrowserRuntime({
-            alias: this.alias,
-            kind: 'browser',
-            driver,
-            ...(launch ? { launch } : {}),
-        });
-    }
-    async playwright(launch) {
-        const runtime = await this.createRuntimeRecord('playwright', launch);
-        return createBrowserRuntimeClientForDriver(this.workspaceClient, runtime, 'playwright');
-    }
-    async puppeteer(launch) {
-        const runtime = await this.createRuntimeRecord('puppeteer', launch);
-        return createBrowserRuntimeClientForDriver(this.workspaceClient, runtime, 'puppeteer');
-    }
-    async stagehand(launch) {
-        const runtime = await this.createRuntimeRecord('stagehand', launch);
-        return createBrowserRuntimeClientForDriver(this.workspaceClient, runtime, 'stagehand');
-    }
-    async selenium(launch) {
-        const runtime = await this.createRuntimeRecord('selenium', launch);
-        return createBrowserRuntimeClientForDriver(this.workspaceClient, runtime, 'selenium');
-    }
-    async get() {
-        const runtime = await this.workspaceClient.getRuntime(this.alias);
-        if (!runtime) {
-            throw new Error(`Runtime '${this.alias}' not found in workspace '${this.workspaceClient.id}'`);
-        }
-        return createBrowserRuntimeClient(this.workspaceClient, runtime);
-    }
-}
-export class RuntimeNamespace {
-    workspaceClient;
-    constructor(workspaceClient) {
-        this.workspaceClient = workspaceClient;
-    }
-    async list() {
-        const response = await fetchWithTimeout(`${this.workspaceClient.baseUrl}/workspaces/${encodeURIComponent(this.workspaceClient.id)}/runtimes`, {
-            headers: buildHeaders(this.workspaceClient.apiKey),
-        });
-        const data = await expectJson(response, 'List runtimes');
-        return data.runtimes;
-    }
-    browser(alias) {
-        return new BrowserRuntimeBuilder(this.workspaceClient, alias);
-    }
-}