@bctrl/sdk 1.0.1

package/dist/workspaces/browser-runtime.d.ts

@@ -0,0 +1,251 @@
+import type { BrowserRuntimeLaunch, BrowserRuntimeCreateRequest, Runtime, RuntimeEventsListQuery, RuntimeEventsListResponse, RuntimeEventsWaitRequest, RuntimeEventsWaitResponse, WorkspaceExecuteRequest, WorkspaceExecuteResponse, WorkspaceHelpRequest, WorkspaceHelpResponse, WorkspaceStateQuery, WorkspaceStateResponse, RuntimeLiveEmbedRequest, RuntimeLiveEmbedResponse, RuntimeRecordingEmbedResponse } from '../contracts/public-api.js';
+import { CaptchaNamespace } from '../captcha/namespace.js';
+import type { BrowserUseAgentConfig, BrowserUseCodeAgentConfig, BrowserUseExecuteOptions } from '../contracts/browser-use.js';
+import type { StagehandAgentConfig, StagehandAgentExecuteOptions, StagehandExtractResult, StagehandHistoryEntry, StagehandMetrics, StagehandObserveResult } from '../contracts/stagehand.js';
+import type { RpcSender, SimpleRpcSender } from '../internal/transport.js';
+import { type ActOptionsWithPage, type ExtractOptionsWithPage, type ObserveOptionsWithPage, type PageResolver } from '../agents/stagehand/core.js';
+import { RemotePlaywrightBrowser } from '../drivers/playwright/generated/browser.js';
+import { RemotePlaywrightBrowserContext } from '../drivers/playwright/generated/browser-context.js';
+import { RemotePlaywrightPage } from '../drivers/playwright/generated/page.js';
+import { RemotePuppeteerBrowser } from '../drivers/puppeteer/generated/browser.js';
+import { RemotePuppeteerPage } from '../drivers/puppeteer/generated/page.js';
+import type { PageEvents as PuppeteerPageEvents } from '../drivers/puppeteer/types.js';
+import { RemoteStagehandPage } from '../drivers/stagehand/generated/page.js';
+import type { WebDriver } from '../drivers/selenium/types.js';
+import { RuntimeEventPump } from './runtime-event-pump.js';
+export type BrowserRuntimeRecordingEmbed = Omit<RuntimeRecordingEmbedResponse, 'iframeUrl'> & {
+    iframeUrl: string;
+};
+export type BrowserRuntimeLiveEmbed = Omit<RuntimeLiveEmbedResponse, 'iframeUrl'> & {
+    iframeUrl: string;
+};
+export interface RuntimeRunRequest {
+    idempotencyKey?: string;
+    mode?: WorkspaceExecuteRequest['mode'];
+    steps: WorkspaceExecuteRequest['steps'];
+}
+interface BrowserRuntimeWorkspaceBridge {
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    readonly id: string;
+    execute(request: WorkspaceExecuteRequest): Promise<WorkspaceExecuteResponse>;
+    state(query?: WorkspaceStateQuery): Promise<WorkspaceStateResponse>;
+    help(request?: WorkspaceHelpRequest): Promise<WorkspaceHelpResponse>;
+    createBrowserRuntime(request: BrowserRuntimeCreateRequest): Promise<Runtime>;
+    stopRuntime(alias: string): Promise<Runtime>;
+    getRuntime(alias: string): Promise<Runtime | null>;
+    embedRuntimeLive(alias: string, request?: RuntimeLiveEmbedRequest): Promise<BrowserRuntimeLiveEmbed>;
+    embedRuntimeRecording(alias: string): Promise<BrowserRuntimeRecordingEmbed>;
+}
+type AutomationIds = {
+    contextId?: string;
+    pageId?: string;
+    handleId?: string;
+};
+type StepOptions = WorkspaceExecuteRequest['steps'][number]['options'];
+type WaitForEventPredicate<T> = (value: T) => boolean | Promise<boolean>;
+export interface RuntimePuppeteerPage extends RemotePuppeteerPage {
+    waitForEvent<K extends keyof PuppeteerPageEvents>(event: K, optionsOrPredicate?: {
+        predicate?: WaitForEventPredicate<PuppeteerPageEvents[K]>;
+        timeout?: number;
+    } | WaitForEventPredicate<PuppeteerPageEvents[K]>): Promise<PuppeteerPageEvents[K]>;
+}
+export interface RuntimeStagehandPage extends RemoteStagehandPage {
+    waitForEvent<T = unknown>(event: string, optionsOrPredicate?: {
+        predicate?: WaitForEventPredicate<T>;
+        timeout?: number;
+    } | WaitForEventPredicate<T>): Promise<T>;
+}
+declare module '../drivers/puppeteer/generated/page.js' {
+    interface RemotePuppeteerPage {
+        waitForEvent<K extends keyof PuppeteerPageEvents>(event: K, optionsOrPredicate?: {
+            predicate?: WaitForEventPredicate<PuppeteerPageEvents[K]>;
+            timeout?: number;
+        } | WaitForEventPredicate<PuppeteerPageEvents[K]>): Promise<PuppeteerPageEvents[K]>;
+    }
+}
+declare module '../drivers/stagehand/generated/page.js' {
+    interface RemoteStagehandPage {
+        waitForEvent<T = unknown>(event: string, optionsOrPredicate?: {
+            predicate?: WaitForEventPredicate<T>;
+            timeout?: number;
+        } | WaitForEventPredicate<T>): Promise<T>;
+    }
+}
+declare class RuntimeExecutionTransport {
+    private readonly workspaceClient;
+    private readonly runtimeAlias;
+    private contextId;
+    private activePageId;
+    constructor(workspaceClient: BrowserRuntimeWorkspaceBridge, runtimeAlias: string, runtime?: Runtime);
+    getContextId(): string | undefined;
+    getActivePageId(): string | undefined;
+    noteContext(contextId: string | undefined): void;
+    notePage(pageId: string | undefined, contextId?: string): void;
+    private buildRef;
+    private rememberCallResult;
+    private executeSingleStep;
+    executeImmediate<T>(call: string, args?: unknown[], ids?: AutomationIds, options?: StepOptions): Promise<T>;
+    executeOperationAware(call: string, args?: unknown[], ids?: AutomationIds, options?: StepOptions): Promise<WorkspaceExecuteResponse>;
+    createRpcSender(): RpcSender;
+    createPageSender(pageId: string, contextId?: string): SimpleRpcSender;
+    createContextSender(contextId: string): SimpleRpcSender;
+    createBrowserSender(): SimpleRpcSender;
+    createHandleSender(target: 'frame' | 'jsHandle' | 'element' | 'dialog', handleId: string): SimpleRpcSender;
+    createLocatorSender(selector: string, pageId: string, contextId?: string): SimpleRpcSender;
+}
+declare class BrowserRuntimeEventsClient {
+    private readonly workspaceClient;
+    private readonly runtimeAlias;
+    constructor(workspaceClient: BrowserRuntimeWorkspaceBridge, runtimeAlias: string);
+    list(query?: RuntimeEventsListQuery): Promise<RuntimeEventsListResponse>;
+    wait(request?: RuntimeEventsWaitRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<RuntimeEventsWaitResponse>;
+}
+export declare class BrowserRuntimeAccessor {
+    protected readonly workspaceClient: BrowserRuntimeWorkspaceBridge;
+    protected readonly runtimeAlias: string;
+    readonly events: BrowserRuntimeEventsClient;
+    constructor(workspaceClient: BrowserRuntimeWorkspaceBridge, runtimeAlias: string);
+    run(input: RuntimeRunRequest): Promise<WorkspaceExecuteResponse>;
+    state(): Promise<WorkspaceStateResponse>;
+    help(topic?: string): Promise<WorkspaceHelpResponse>;
+    live(options?: RuntimeLiveEmbedRequest): Promise<BrowserRuntimeLiveEmbed>;
+    recording(): Promise<BrowserRuntimeRecordingEmbed>;
+    stop(): Promise<Runtime>;
+}
+export declare class BrowserRuntimeClient extends BrowserRuntimeAccessor {
+    protected runtimeValue: Runtime;
+    protected readonly transport: RuntimeExecutionTransport;
+    private eventPump;
+    private _captcha;
+    constructor(workspaceClient: BrowserRuntimeWorkspaceBridge, runtimeValue: Runtime);
+    get id(): string;
+    get alias(): string;
+    get driverName(): string;
+    get status(): string;
+    get captcha(): CaptchaNamespace;
+    protected getEventPump(): RuntimeEventPump;
+    protected registerPageEventEmitter(registration: Parameters<RuntimeEventPump['registerPageEmitter']>[0]): void;
+    protected registerContextEventEmitter(registration: Parameters<RuntimeEventPump['registerContextEmitter']>[0]): void;
+    stop(): Promise<Runtime>;
+}
+declare class RuntimeStagehandAgent<TPage = unknown> {
+    private readonly transport;
+    private readonly getContextId;
+    private readonly resolvePageId;
+    private readonly config?;
+    constructor(transport: RuntimeExecutionTransport, getContextId: () => string | undefined, resolvePageId: (page?: TPage) => string | undefined, config?: StagehandAgentConfig | undefined);
+    execute(instruction: string, options?: Omit<StagehandAgentExecuteOptions, 'instruction' | 'pageId'> & {
+        page?: TPage;
+    }): Promise<WorkspaceExecuteResponse>;
+    execute(options: Omit<StagehandAgentExecuteOptions, 'pageId'> & {
+        page?: TPage;
+    }): Promise<WorkspaceExecuteResponse>;
+}
+declare class RuntimeStagehandNamespace<TPage = unknown> {
+    private readonly transport;
+    private readonly getContextId;
+    private readonly getActivePageId;
+    private readonly resolvePage;
+    private readonly core;
+    constructor(transport: RuntimeExecutionTransport, getContextId: () => string | undefined, getActivePageId: () => string | undefined, resolvePage: PageResolver<TPage>);
+    act(instruction: string, options?: ActOptionsWithPage<TPage>): Promise<{
+        success: boolean;
+        message: string;
+        actionDescription: string;
+        actions: {
+            selector: string;
+            description: string;
+            method?: string | undefined;
+            arguments?: string[] | undefined;
+        }[];
+        cacheStatus?: "HIT" | "MISS" | undefined;
+    }>;
+    extract(options?: ExtractOptionsWithPage<TPage>): Promise<StagehandExtractResult<{
+        pageText: string;
+    }>>;
+    extract<T>(instruction: string, schema: T, options?: ExtractOptionsWithPage<TPage>): Promise<StagehandExtractResult<T>>;
+    observe(options?: ObserveOptionsWithPage<TPage>): Promise<StagehandObserveResult>;
+    observe(instruction: string, options?: ObserveOptionsWithPage<TPage>): Promise<StagehandObserveResult>;
+    agent(config?: StagehandAgentConfig): RuntimeStagehandAgent<TPage>;
+    getMetrics(): Promise<StagehandMetrics>;
+    getHistory(): Promise<StagehandHistoryEntry[]>;
+}
+declare class RuntimeBrowserUseNamespace {
+    private readonly transport;
+    private readonly getActivePageId;
+    constructor(transport: RuntimeExecutionTransport, getActivePageId: () => string | undefined);
+    agent(config?: BrowserUseAgentConfig): {
+        execute: (task: string, options?: BrowserUseExecuteOptions) => Promise<WorkspaceExecuteResponse>;
+    };
+    codeAgent(config?: BrowserUseCodeAgentConfig): {
+        execute: (task: string, options?: BrowserUseExecuteOptions) => Promise<WorkspaceExecuteResponse>;
+    };
+}
+declare abstract class AgentBrowserRuntimeClient<TPage> extends BrowserRuntimeClient {
+    private _stagehand;
+    private _browserUse;
+    protected abstract resolvePage(page?: unknown): string | undefined;
+    get stagehand(): RuntimeStagehandNamespace<TPage>;
+    get browserUse(): RuntimeBrowserUseNamespace;
+}
+export declare class PlaywrightBrowserRuntimeClient extends AgentBrowserRuntimeClient<RemotePlaywrightPage> {
+    private _browser;
+    private _defaultPage;
+    private readonly contextCache;
+    private readonly pageCache;
+    private readonly pageContextIds;
+    protected resolvePage(page?: unknown): string | undefined;
+    get browser(): RemotePlaywrightBrowser;
+    get browserContext(): RemotePlaywrightBrowserContext;
+    get page(): RemotePlaywrightPage;
+    getPages(): Promise<RemotePlaywrightPage[]>;
+    private resolvePageContextId;
+    private getOrCreateBrowserContext;
+    private createPlaywrightPage;
+}
+export declare class PuppeteerBrowserRuntimeClient extends AgentBrowserRuntimeClient<RemotePuppeteerPage> {
+    private _browser;
+    private _defaultPage;
+    private readonly contextCache;
+    private readonly pageCache;
+    protected resolvePage(page?: unknown): string | undefined;
+    get browser(): RemotePuppeteerBrowser;
+    get page(): RuntimePuppeteerPage;
+    private getOrCreateBrowserContext;
+    private createPuppeteerPage;
+}
+export declare class StagehandBrowserRuntimeClient extends AgentBrowserRuntimeClient<RemoteStagehandPage> {
+    private _page;
+    private readonly pageCache;
+    protected resolvePage(page?: unknown): string | undefined;
+    get page(): RuntimeStagehandPage;
+    private createStagehandPage;
+}
+export declare class SeleniumBrowserRuntimeClient extends AgentBrowserRuntimeClient<unknown> {
+    private _webDriver;
+    protected resolvePage(): string | undefined;
+    get webDriver(): WebDriver;
+    get driver(): WebDriver;
+}
+export type AnyBrowserRuntimeClient = BrowserRuntimeClient | PlaywrightBrowserRuntimeClient | PuppeteerBrowserRuntimeClient | StagehandBrowserRuntimeClient | SeleniumBrowserRuntimeClient;
+export declare function createBrowserRuntimeClient(workspaceClient: BrowserRuntimeWorkspaceBridge, runtime: Runtime): AnyBrowserRuntimeClient;
+export declare class BrowserRuntimeBuilder extends BrowserRuntimeAccessor {
+    private readonly alias;
+    constructor(workspaceClient: BrowserRuntimeWorkspaceBridge, alias: string);
+    private createRuntimeRecord;
+    playwright(launch?: BrowserRuntimeLaunch): Promise<PlaywrightBrowserRuntimeClient>;
+    puppeteer(launch?: BrowserRuntimeLaunch): Promise<PuppeteerBrowserRuntimeClient>;
+    stagehand(launch?: BrowserRuntimeLaunch): Promise<StagehandBrowserRuntimeClient>;
+    selenium(launch?: BrowserRuntimeLaunch): Promise<SeleniumBrowserRuntimeClient>;
+    get(): Promise<AnyBrowserRuntimeClient>;
+}
+export declare class RuntimeNamespace {
+    private readonly workspaceClient;
+    constructor(workspaceClient: BrowserRuntimeWorkspaceBridge);
+    list(): Promise<Runtime[]>;
+    browser(alias: string): BrowserRuntimeBuilder;
+}
+export {};