@bctrl/sdk 1.0.1

package/dist/workspaces/browser-runtime.js

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