@bctrl/sdk 1.0.2 → 1.0.4

package/dist/invocations.js

@@ -1,4 +1,4 @@
-export class V2InvocationResource {
+export class V1InvocationResource {
     http;
     data;
     constructor(http, data) {
@@ -27,14 +27,14 @@ export class V2InvocationResource {
             .then((response) => response.data);
     }
 }
-export class V2InvocationsClient {
+export class V1InvocationsClient {
     http;
     constructor(http) {
         this.http = http;
     }
     async get(id) {
         const response = await this.http.request(`/invocations/${encodeURIComponent(id)}`);
-        return new V2InvocationResource(this.http, response.data);
+        return new V1InvocationResource(this.http, response.data);
     }
     wait(id, request) {
         return this.http.request(`/invocations/${encodeURIComponent(id)}/wait`, {
@@ -46,21 +46,114 @@ export class V2InvocationsClient {
         const response = await this.http.request(`/invocations/${encodeURIComponent(id)}/cancel`, {
             method: 'POST',
         });
-        return new V2InvocationResource(this.http, response.data);
+        return new V1InvocationResource(this.http, response.data);
     }
 }
-export class V2RuntimeInvocationsClient {
+export class V1RuntimeInvocationsClient {
     http;
     runtimeId;
+    stagehand;
+    browserUse;
     constructor(http, runtimeId) {
         this.http = http;
         this.runtimeId = runtimeId;
+        this.stagehand = new V1RuntimeStagehandInvocationsClient(this);
+        this.browserUse = new V1RuntimeBrowserUseInvocationsClient(this);
     }
     async create(request) {
         const response = await this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/invocations`, {
             method: 'POST',
             body: request,
         });
-        return new V2InvocationResource(this.http, response.data);
+        return new V1InvocationResource(this.http, response.data);
     }
 }
+export class V1RuntimeStagehandInvocationsClient {
+    invocations;
+    constructor(invocations) {
+        this.invocations = invocations;
+    }
+    act(options) {
+        const { instruction, timeoutMs, ...common } = options;
+        return this.invocations.create({
+            provider: 'stagehand',
+            method: 'act',
+            ...common,
+            input: {
+                instruction,
+                ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+            },
+        });
+    }
+    observe(options) {
+        const { instruction, selector, timeoutMs, ...common } = options;
+        return this.invocations.create({
+            provider: 'stagehand',
+            method: 'observe',
+            ...common,
+            input: {
+                instruction,
+                ...(selector !== undefined ? { selector } : {}),
+                ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+            },
+        });
+    }
+    extract(options) {
+        const { instruction, schema, ...common } = options;
+        return this.invocations.create({
+            provider: 'stagehand',
+            method: 'extract',
+            ...common,
+            input: { instruction },
+            ...(schema !== undefined ? { outputSchema: toJsonSchemaObject(schema) } : {}),
+        });
+    }
+    agent(options) {
+        const { instruction, maxSteps, timeoutMs, variables, config, options: agentOptions, ...common } = options;
+        return this.invocations.create({
+            provider: 'stagehand',
+            method: 'agent',
+            ...common,
+            input: {
+                instruction,
+                ...(maxSteps !== undefined ? { maxSteps } : {}),
+                ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+                ...(variables !== undefined ? { variables } : {}),
+            },
+            ...(config !== undefined ? { config } : {}),
+            ...(agentOptions !== undefined ? { options: agentOptions } : {}),
+        });
+    }
+}
+export class V1RuntimeBrowserUseInvocationsClient {
+    invocations;
+    constructor(invocations) {
+        this.invocations = invocations;
+    }
+    agent(options) {
+        const { instruction, maxSteps, config, options: agentOptions, ...common } = options;
+        return this.invocations.create({
+            provider: 'browserUse',
+            method: 'agent',
+            ...common,
+            input: {
+                instruction,
+                ...(maxSteps !== undefined ? { maxSteps } : {}),
+            },
+            ...(config !== undefined ? { config } : {}),
+            ...(agentOptions !== undefined ? { options: agentOptions } : {}),
+        });
+    }
+}
+function toJsonSchemaObject(schema) {
+    const value = typeof schema.toJSONSchema === 'function' ? schema.toJSONSchema() : schema;
+    if (!isJsonObject(value)) {
+        throw new TypeError('Stagehand extract schema must resolve to a JSON object');
+    }
+    const { $schema, ...jsonSchema } = value;
+    void $schema;
+    return jsonSchema;
+}
+function isJsonObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/pagination.d.ts

@@ -1,2 +1,2 @@
-import type { V2ListEnvelope, V2PageQuery } from './types.js';
-export declare function iterateV2Pages<T, Q extends V2PageQuery>(initialQuery: Q, fetchPage: (query: Q) => Promise<V2ListEnvelope<T>>): AsyncGenerator<T, void, undefined>;
+import type { V1ListEnvelope, V1PageQuery } from './types.js';
+export declare function iterateV1Pages<T, Q extends V1PageQuery>(initialQuery: Q, fetchPage: (query: Q) => Promise<V1ListEnvelope<T>>): AsyncGenerator<T, void, undefined>;

package/dist/pagination.js

@@ -1,4 +1,4 @@
-export async function* iterateV2Pages(initialQuery, fetchPage) {
+export async function* iterateV1Pages(initialQuery, fetchPage) {
     let cursor = initialQuery.cursor;
     for (;;) {
         const page = await fetchPage({ ...initialQuery, cursor });

package/dist/runs.d.ts

@@ -1,38 +1,40 @@
-import type { V2HttpClient } from './http.js';
-import { V2RunFilesClient } from './files.js';
-import type { V2ListEnvelope, V2Run, V2RunCommand, V2RunCommandsListQuery, V2RunEvent, V2RunEventsListQuery, V2RunEventsWaitRequest, V2RunEventsWaitResponse, V2RunListQuery, V2RunLiveRequest, V2RunLiveResponse, V2RunRecordingRequest, V2RunRecordingResponse } from './types.js';
-export declare class V2RunEventsClient {
+import type { V1HttpClient } from './http.js';
+import { V1RunFilesClient } from './files.js';
+import type { V1ListEnvelope, V1Run, V1RunCommand, V1RunCommandsListQuery, V1RunEvent, V1RunEventsListQuery, V1RunEventsWaitRequest, V1RunEventsWaitResponse, V1RunListQuery, V1RunLiveRequest, V1RunLiveResponse, V1RunRecordingRequest, V1RunRecordingResponse, V1RuntimeStartRun, V1RunUsage } from './types.js';
+export declare class V1RunEventsClient {
     private readonly http;
     private readonly runId;
-    constructor(http: V2HttpClient, runId: string);
-    list(query?: V2RunEventsListQuery): Promise<V2ListEnvelope<V2RunEvent>>;
-    iter(query?: V2RunEventsListQuery): AsyncGenerator<V2RunEvent, void, undefined>;
-    wait(request?: V2RunEventsWaitRequest): Promise<V2RunEventsWaitResponse>;
-    streamUrl(query?: Pick<V2RunEventsListQuery, 'type' | 'category' | 'connectionId'>): string;
+    constructor(http: V1HttpClient, runId: string);
+    list(query?: V1RunEventsListQuery): Promise<V1ListEnvelope<V1RunEvent>>;
+    iter(query?: V1RunEventsListQuery): AsyncGenerator<V1RunEvent, void, undefined>;
+    wait(request?: V1RunEventsWaitRequest): Promise<V1RunEventsWaitResponse>;
+    streamUrl(query?: Pick<V1RunEventsListQuery, 'type' | 'category' | 'connectionId'>): string;
 }
-export declare class V2RunCommandsClient {
+export declare class V1RunCommandsClient {
     private readonly http;
     private readonly runId;
-    constructor(http: V2HttpClient, runId: string);
-    list(query?: V2RunCommandsListQuery): Promise<V2ListEnvelope<V2RunCommand>>;
-    iter(query?: V2RunCommandsListQuery): AsyncGenerator<V2RunCommand, void, undefined>;
+    constructor(http: V1HttpClient, runId: string);
+    list(query?: V1RunCommandsListQuery): Promise<V1ListEnvelope<V1RunCommand>>;
+    iter(query?: V1RunCommandsListQuery): AsyncGenerator<V1RunCommand, void, undefined>;
 }
-export declare class V2RunResource {
+export declare class V1RunResource {
     private readonly http;
-    readonly data: V2Run;
-    readonly events: V2RunEventsClient;
-    readonly commands: V2RunCommandsClient;
-    readonly files: V2RunFilesClient;
-    constructor(http: V2HttpClient, data: V2Run);
+    readonly data: V1Run | V1RuntimeStartRun;
+    readonly events: V1RunEventsClient;
+    readonly commands: V1RunCommandsClient;
+    readonly files: V1RunFilesClient;
+    constructor(http: V1HttpClient, data: V1Run | V1RuntimeStartRun);
     get id(): string;
-    refresh(): Promise<V2RunResource>;
-    live(request?: V2RunLiveRequest): Promise<V2RunLiveResponse>;
-    recording(request?: V2RunRecordingRequest): Promise<V2RunRecordingResponse>;
+    refresh(): Promise<V1RunResource>;
+    live(request?: V1RunLiveRequest): Promise<V1RunLiveResponse>;
+    recording(request?: V1RunRecordingRequest): Promise<V1RunRecordingResponse>;
+    usage(): Promise<V1RunUsage>;
 }
-export declare class V2RunsClient {
+export declare class V1RunsClient {
     private readonly http;
-    constructor(http: V2HttpClient);
-    list(query?: V2RunListQuery): Promise<V2ListEnvelope<V2Run>>;
-    iter(query?: V2RunListQuery): AsyncGenerator<V2Run, void, undefined>;
-    get(id: string): Promise<V2RunResource>;
+    constructor(http: V1HttpClient);
+    list(query?: V1RunListQuery): Promise<V1ListEnvelope<V1Run>>;
+    iter(query?: V1RunListQuery): AsyncGenerator<V1Run, void, undefined>;
+    get(id: string): Promise<V1RunResource>;
+    usage(id: string): Promise<V1RunUsage>;
 }

package/dist/runs.js

@@ -1,6 +1,6 @@
-import { iterateV2Pages } from './pagination.js';
-import { V2RunFilesClient } from './files.js';
-export class V2RunEventsClient {
+import { iterateV1Pages } from './pagination.js';
+import { V1RunFilesClient } from './files.js';
+export class V1RunEventsClient {
     http;
     runId;
     constructor(http, runId) {
@@ -11,7 +11,7 @@ export class V2RunEventsClient {
         return this.http.request(`/runs/${encodeURIComponent(this.runId)}/events`, { query });
     }
     iter(query = {}) {
-        return iterateV2Pages(query, (pageQuery) => this.list(pageQuery));
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
     wait(request) {
         return this.http.request(`/runs/${encodeURIComponent(this.runId)}/events/wait`, {
@@ -35,7 +35,7 @@ export class V2RunEventsClient {
         return url.toString();
     }
 }
-export class V2RunCommandsClient {
+export class V1RunCommandsClient {
     http;
     runId;
     constructor(http, runId) {
@@ -46,10 +46,10 @@ export class V2RunCommandsClient {
         return this.http.request(`/runs/${encodeURIComponent(this.runId)}/commands`, { query });
     }
     iter(query = {}) {
-        return iterateV2Pages(query, (pageQuery) => this.list(pageQuery));
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
 }
-export class V2RunResource {
+export class V1RunResource {
     http;
     data;
     events;
@@ -58,15 +58,15 @@ export class V2RunResource {
     constructor(http, data) {
         this.http = http;
         this.data = data;
-        this.events = new V2RunEventsClient(http, data.id);
-        this.commands = new V2RunCommandsClient(http, data.id);
-        this.files = new V2RunFilesClient(http, data.id);
+        this.events = new V1RunEventsClient(http, data.id);
+        this.commands = new V1RunCommandsClient(http, data.id);
+        this.files = new V1RunFilesClient(http, data.id);
     }
     get id() {
         return this.data.id;
     }
     refresh() {
-        return new V2RunsClient(this.http).get(this.id);
+        return new V1RunsClient(this.http).get(this.id);
     }
     live(request) {
         return this.http.request(`/runs/${encodeURIComponent(this.id)}/live`, {
@@ -80,8 +80,11 @@ export class V2RunResource {
             body: request ?? {},
         });
     }
+    usage() {
+        return this.http.request(`/runs/${encodeURIComponent(this.id)}/usage`);
+    }
 }
-export class V2RunsClient {
+export class V1RunsClient {
     http;
     constructor(http) {
         this.http = http;
@@ -90,10 +93,13 @@ export class V2RunsClient {
         return this.http.request('/runs', { query });
     }
     iter(query = {}) {
-        return iterateV2Pages(query, (pageQuery) => this.list(pageQuery));
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
     async get(id) {
         const run = await this.http.request(`/runs/${encodeURIComponent(id)}`);
-        return new V2RunResource(this.http, run);
+        return new V1RunResource(this.http, run);
+    }
+    usage(id) {
+        return this.http.request(`/runs/${encodeURIComponent(id)}/usage`);
     }
 }

package/dist/runtimes.d.ts

@@ -1,73 +1,49 @@
-import type { V2HttpClient } from './http.js';
-import { V2RuntimeInvocationsClient } from './invocations.js';
-import { V2RunResource } from './runs.js';
-import type { V2ListEnvelope, V2File, V2Runtime, V2RuntimeConnection, V2RuntimeConnectionCreateOptions, V2RuntimeConnectionCreateResponse, V2RuntimeCreateRequest, V2RuntimeFileCollectRequest, V2RuntimeFileStageRequest, V2RuntimeFileUploadRequest, V2RuntimeFileUploadResponse, V2RuntimeStagedFile, V2RuntimeListQuery, V2RuntimeRunListQuery, V2RunSummary, V2SpaceRuntimeCreateRequest } from './types.js';
-export declare class V2RuntimeConnectionResource {
+import type { V1HttpClient } from './http.js';
+import { V1RuntimeInvocationsClient } from './invocations.js';
+import { V1RunResource } from './runs.js';
+import type { V1ListEnvelope, V1File, V1Runtime, V1RuntimeCreateRequest, V1RuntimeFileCollectRequest, V1RuntimeFileStageRequest, V1RuntimeFileUploadRequest, V1RuntimeFileUploadResponse, V1RuntimeStagedFile, V1RuntimeListQuery, V1RuntimeRunListQuery, V1RuntimeStartBrowser, V1RuntimeStartRuntime, V1RunSummary, V1SpaceRuntimeCreateRequest } from './types.js';
+export type V1RuntimeStartResult = {
+    runtime: V1RuntimeResource;
+    run: V1RunResource;
+    browser: V1RuntimeStartBrowser;
+};
+export declare class V1RuntimeRunsClient {
     private readonly http;
     private readonly runtimeId;
-    readonly data: V2RuntimeConnectionCreateResponse;
-    constructor(http: V2HttpClient, runtimeId: string, data: V2RuntimeConnectionCreateResponse);
-    get id(): string;
-    get endpoint(): V2RuntimeConnectionCreateResponse['endpoint'];
-    get wsUrl(): string | undefined;
-    close(): Promise<V2RuntimeConnection>;
-}
-export declare class V2RuntimeConnectionsClient {
-    private readonly http;
-    private readonly runtimeId;
-    constructor(http: V2HttpClient, runtimeId: string);
-    create(request?: V2RuntimeConnectionCreateOptions): Promise<V2RuntimeConnectionResource>;
-    list(query?: {
-        status?: string | string[];
-        limit?: number;
-    }): Promise<V2ListEnvelope<V2RuntimeConnection>>;
-    delete(connectionId: string): Promise<V2RuntimeConnection>;
-}
-export declare class V2RuntimeRunsClient {
-    private readonly http;
-    private readonly runtimeId;
-    constructor(http: V2HttpClient, runtimeId: string);
-    list(query?: V2RuntimeRunListQuery): Promise<V2ListEnvelope<V2RunSummary>>;
-    iter(query?: V2RuntimeRunListQuery): AsyncGenerator<V2RunSummary, void, undefined>;
+    constructor(http: V1HttpClient, runtimeId: string);
+    list(query?: V1RuntimeRunListQuery): Promise<V1ListEnvelope<V1RunSummary>>;
+    iter(query?: V1RuntimeRunListQuery): AsyncGenerator<V1RunSummary, void, undefined>;
 }
-export declare class V2RuntimeFilesClient {
+export declare class V1RuntimeFilesClient {
     private readonly http;
     private readonly runtimeId;
-    constructor(http: V2HttpClient, runtimeId: string);
-    upload(request: V2RuntimeFileUploadRequest): Promise<V2RuntimeFileUploadResponse>;
-    stage(request: V2RuntimeFileStageRequest): Promise<V2RuntimeStagedFile>;
-    collect(request: V2RuntimeFileCollectRequest): Promise<V2File>;
+    constructor(http: V1HttpClient, runtimeId: string);
+    upload(request: V1RuntimeFileUploadRequest): Promise<V1RuntimeFileUploadResponse>;
+    stage(request: V1RuntimeFileStageRequest): Promise<V1RuntimeStagedFile>;
+    collect(request: V1RuntimeFileCollectRequest): Promise<V1File>;
 }
-export declare class V2RuntimeResource {
+export declare class V1RuntimeResource {
     private readonly http;
-    readonly data: V2Runtime;
-    readonly connections: V2RuntimeConnectionsClient;
-    readonly files: V2RuntimeFilesClient;
-    readonly runs: V2RuntimeRunsClient;
-    readonly invocations: V2RuntimeInvocationsClient;
-    constructor(http: V2HttpClient, data: V2Runtime);
+    readonly data: V1Runtime | V1RuntimeStartRuntime;
+    readonly files: V1RuntimeFilesClient;
+    readonly runs: V1RuntimeRunsClient;
+    readonly invocations: V1RuntimeInvocationsClient;
+    constructor(http: V1HttpClient, data: V1Runtime | V1RuntimeStartRuntime);
     get id(): string;
     get activeRunId(): string | null;
-    refresh(): Promise<V2RuntimeResource>;
-    connect(request?: V2RuntimeConnectionCreateOptions): Promise<V2RuntimeConnectionResource>;
-    start(): Promise<{
-        runtime: V2RuntimeResource;
-        run: V2RunResource;
-    }>;
-    stop(): Promise<V2Runtime>;
-    run(): Promise<V2RunResource>;
+    refresh(): Promise<V1RuntimeResource>;
+    start(): Promise<V1RuntimeStartResult>;
+    stop(): Promise<V1Runtime>;
+    run(): Promise<V1RunResource>;
 }
-export declare class V2RuntimesClient {
+export declare class V1RuntimesClient {
     private readonly http;
-    constructor(http: V2HttpClient);
-    list(query?: V2RuntimeListQuery): Promise<V2ListEnvelope<V2Runtime>>;
-    iter(query?: V2RuntimeListQuery): AsyncGenerator<V2Runtime, void, undefined>;
-    create(request: V2RuntimeCreateRequest): Promise<V2RuntimeResource>;
-    createInSpace(spaceId: string, request: V2SpaceRuntimeCreateRequest): Promise<V2RuntimeResource>;
-    get(id: string): Promise<V2RuntimeResource>;
-    stop(id: string): Promise<V2Runtime>;
-    start(id: string): Promise<{
-        runtime: V2RuntimeResource;
-        run: V2RunResource;
-    }>;
+    constructor(http: V1HttpClient);
+    list(query?: V1RuntimeListQuery): Promise<V1ListEnvelope<V1Runtime>>;
+    iter(query?: V1RuntimeListQuery): AsyncGenerator<V1Runtime, void, undefined>;
+    create(request: V1RuntimeCreateRequest): Promise<V1RuntimeResource>;
+    createInSpace(spaceId: string, request: V1SpaceRuntimeCreateRequest): Promise<V1RuntimeResource>;
+    get(id: string): Promise<V1RuntimeResource>;
+    stop(id: string): Promise<V1Runtime>;
+    start(id: string): Promise<V1RuntimeStartResult>;
 }

package/dist/runtimes.js

@@ -1,54 +1,8 @@
 import { BctrlValidationError } from './errors.js';
-import { V2RuntimeInvocationsClient } from './invocations.js';
-import { iterateV2Pages } from './pagination.js';
-import { V2RunResource } from './runs.js';
-export class V2RuntimeConnectionResource {
-    http;
-    runtimeId;
-    data;
-    constructor(http, runtimeId, data) {
-        this.http = http;
-        this.runtimeId = runtimeId;
-        this.data = data;
-    }
-    get id() {
-        return this.data.id;
-    }
-    get endpoint() {
-        return this.data.endpoint;
-    }
-    get wsUrl() {
-        return this.data.endpoint.type === 'websocket' ? this.data.endpoint.url : undefined;
-    }
-    close() {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections/${encodeURIComponent(this.id)}`, { method: 'DELETE' });
-    }
-}
-export class V2RuntimeConnectionsClient {
-    http;
-    runtimeId;
-    constructor(http, runtimeId) {
-        this.http = http;
-        this.runtimeId = runtimeId;
-    }
-    async create(request = {}) {
-        const response = await this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections`, {
-            method: 'POST',
-            body: {
-                protocol: request.protocol ?? 'cdp',
-                ...request,
-            },
-        });
-        return new V2RuntimeConnectionResource(this.http, this.runtimeId, response);
-    }
-    list(query = {}) {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections`, { query });
-    }
-    delete(connectionId) {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections/${encodeURIComponent(connectionId)}`, { method: 'DELETE' });
-    }
-}
-export class V2RuntimeRunsClient {
+import { V1RuntimeInvocationsClient } from './invocations.js';
+import { iterateV1Pages } from './pagination.js';
+import { V1RunResource } from './runs.js';
+export class V1RuntimeRunsClient {
     http;
     runtimeId;
     constructor(http, runtimeId) {
@@ -59,10 +13,10 @@ export class V2RuntimeRunsClient {
         return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/runs`, { query });
     }
     iter(query = {}) {
-        return iterateV2Pages(query, (pageQuery) => this.list(pageQuery));
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
 }
-export class V2RuntimeFilesClient {
+export class V1RuntimeFilesClient {
     http;
     runtimeId;
     constructor(http, runtimeId) {
@@ -100,38 +54,34 @@ export class V2RuntimeFilesClient {
         });
     }
 }
-export class V2RuntimeResource {
+export class V1RuntimeResource {
     http;
     data;
-    connections;
     files;
     runs;
     invocations;
     constructor(http, data) {
         this.http = http;
         this.data = data;
-        this.connections = new V2RuntimeConnectionsClient(http, data.id);
-        this.files = new V2RuntimeFilesClient(http, data.id);
-        this.runs = new V2RuntimeRunsClient(http, data.id);
-        this.invocations = new V2RuntimeInvocationsClient(http, data.id);
+        this.files = new V1RuntimeFilesClient(http, data.id);
+        this.runs = new V1RuntimeRunsClient(http, data.id);
+        this.invocations = new V1RuntimeInvocationsClient(http, data.id);
     }
     get id() {
         return this.data.id;
     }
     get activeRunId() {
-        return this.data.activeRunId;
+        return 'activeRunId' in this.data ? this.data.activeRunId : null;
     }
     refresh() {
-        return new V2RuntimesClient(this.http).get(this.id);
-    }
-    async connect(request) {
-        return this.connections.create(request);
+        return new V1RuntimesClient(this.http).get(this.id);
     }
     async start() {
         const response = await this.http.request(`/runtimes/${encodeURIComponent(this.id)}/start`, { method: 'POST' });
         return {
-            runtime: new V2RuntimeResource(this.http, response.runtime),
-            run: new V2RunResource(this.http, response.run),
+            runtime: new V1RuntimeResource(this.http, response.runtime),
+            run: new V1RunResource(this.http, response.run),
+            browser: response.browser,
         };
     }
     stop() {
@@ -141,28 +91,29 @@ export class V2RuntimeResource {
     }
     async run() {
         const runtime = await this.refresh();
-        if (!runtime.activeRunId) {
+        const activeRunId = runtime.activeRunId;
+        if (!activeRunId) {
             throw new BctrlValidationError('Runtime does not have an active run yet', 'runtime.no_active_run', {
                 runtimeId: this.id,
             });
         }
-        const run = await this.http.request(`/runs/${encodeURIComponent(runtime.activeRunId)}`);
-        return new V2RunResource(this.http, run);
+        const run = await this.http.request(`/runs/${encodeURIComponent(activeRunId)}`);
+        return new V1RunResource(this.http, run);
     }
 }
 function validateRuntimeCreateRequest(request) {
-    const profileBacked = request.config?.browser?.profile === true;
+    const profileBacked = request.config?.profile === true;
     if (!profileBacked)
         return;
     if (!request.name?.trim()) {
-        throw new BctrlValidationError('name is required when config.browser.profile is true', 'runtime.profile_name_required');
+        throw new BctrlValidationError('name is required when config.profile is true', 'runtime.profile_name_required');
     }
     const unsupported = ['stealth', 'proxy', 'fingerprint', 'extensions'].filter((key) => request.config?.[key] !== undefined);
     if (unsupported.length > 0) {
-        throw new BctrlValidationError('Only config.browser.profile and config.lifecycle are supported for profile-backed browser runtimes', 'runtime.profile_config_unsupported', { unsupported });
+        throw new BctrlValidationError('Only config.profile, config.idleTimeoutMinutes, config.webRtcProxyOnly, and config.forceOpenShadowRoots are supported for profile-backed browser runtimes', 'runtime.profile_config_unsupported', { unsupported });
     }
 }
-export class V2RuntimesClient {
+export class V1RuntimesClient {
     http;
     constructor(http) {
         this.http = http;
@@ -171,7 +122,7 @@ export class V2RuntimesClient {
         return this.http.request('/runtimes', { query });
     }
     iter(query = {}) {
-        return iterateV2Pages(query, (pageQuery) => this.list(pageQuery));
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
     async create(request) {
         validateRuntimeCreateRequest(request);
@@ -179,7 +130,7 @@ export class V2RuntimesClient {
             method: 'POST',
             body: request,
         });
-        return new V2RuntimeResource(this.http, runtime);
+        return new V1RuntimeResource(this.http, runtime);
     }
     async createInSpace(spaceId, request) {
         validateRuntimeCreateRequest(request);
@@ -187,11 +138,11 @@ export class V2RuntimesClient {
             method: 'POST',
             body: { ...request, spaceId },
         });
-        return new V2RuntimeResource(this.http, runtime);
+        return new V1RuntimeResource(this.http, runtime);
     }
     async get(id) {
         const runtime = await this.http.request(`/runtimes/${encodeURIComponent(id)}`);
-        return new V2RuntimeResource(this.http, runtime);
+        return new V1RuntimeResource(this.http, runtime);
     }
     stop(id) {
         return this.http.request(`/runtimes/${encodeURIComponent(id)}/stop`, {