@bctrl/sdk 1.0.2 → 1.0.3

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, 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;
+    readonly events: V1RunEventsClient;
+    readonly commands: V1RunCommandsClient;
+    readonly files: V1RunFilesClient;
+    constructor(http: V1HttpClient, data: V1Run);
     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,69 @@
-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, V1RuntimeConnection, V1RuntimeConnectionCreateOptions, V1RuntimeConnectionCreateResponse, V1RuntimeCreateRequest, V1RuntimeFileCollectRequest, V1RuntimeFileStageRequest, V1RuntimeFileUploadRequest, V1RuntimeFileUploadResponse, V1RuntimeStagedFile, V1RuntimeListQuery, V1RuntimeRunListQuery, V1RunSummary, V1SpaceRuntimeCreateRequest } from './types.js';
+export declare class V1RuntimeConnectionResource {
     private readonly http;
     private readonly runtimeId;
-    readonly data: V2RuntimeConnectionCreateResponse;
-    constructor(http: V2HttpClient, runtimeId: string, data: V2RuntimeConnectionCreateResponse);
+    readonly data: V1RuntimeConnectionCreateResponse;
+    constructor(http: V1HttpClient, runtimeId: string, data: V1RuntimeConnectionCreateResponse);
     get id(): string;
-    get endpoint(): V2RuntimeConnectionCreateResponse['endpoint'];
+    get endpoint(): V1RuntimeConnectionCreateResponse['endpoint'];
     get wsUrl(): string | undefined;
-    close(): Promise<V2RuntimeConnection>;
+    close(): Promise<V1RuntimeConnection>;
 }
-export declare class V2RuntimeConnectionsClient {
+export declare class V1RuntimeConnectionsClient {
     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>;
+    constructor(http: V1HttpClient, runtimeId: string);
+    create(request?: V1RuntimeConnectionCreateOptions): Promise<V1RuntimeConnectionResource>;
+    delete(connectionId: string): Promise<V1RuntimeConnection>;
 }
-export declare class V2RuntimeRunsClient {
+export declare class V1RuntimeRunsClient {
     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;
+    readonly connections: V1RuntimeConnectionsClient;
+    readonly files: V1RuntimeFilesClient;
+    readonly runs: V1RuntimeRunsClient;
+    readonly invocations: V1RuntimeInvocationsClient;
+    constructor(http: V1HttpClient, data: V1Runtime);
     get id(): string;
     get activeRunId(): string | null;
-    refresh(): Promise<V2RuntimeResource>;
-    connect(request?: V2RuntimeConnectionCreateOptions): Promise<V2RuntimeConnectionResource>;
+    refresh(): Promise<V1RuntimeResource>;
+    connect(request?: V1RuntimeConnectionCreateOptions): Promise<V1RuntimeConnectionResource>;
     start(): Promise<{
-        runtime: V2RuntimeResource;
-        run: V2RunResource;
+        runtime: V1RuntimeResource;
+        run: V1RunResource;
     }>;
-    stop(): Promise<V2Runtime>;
-    run(): Promise<V2RunResource>;
+    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>;
+    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<{
-        runtime: V2RuntimeResource;
-        run: V2RunResource;
+        runtime: V1RuntimeResource;
+        run: V1RunResource;
     }>;
 }

package/dist/runtimes.js

@@ -1,8 +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 {
+import { V1RuntimeInvocationsClient } from './invocations.js';
+import { iterateV1Pages } from './pagination.js';
+import { V1RunResource } from './runs.js';
+export class V1RuntimeConnectionResource {
     http;
     runtimeId;
     data;
@@ -24,7 +24,7 @@ export class V2RuntimeConnectionResource {
         return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections/${encodeURIComponent(this.id)}`, { method: 'DELETE' });
     }
 }
-export class V2RuntimeConnectionsClient {
+export class V1RuntimeConnectionsClient {
     http;
     runtimeId;
     constructor(http, runtimeId) {
@@ -39,16 +39,13 @@ export class V2RuntimeConnectionsClient {
                 ...request,
             },
         });
-        return new V2RuntimeConnectionResource(this.http, this.runtimeId, response);
-    }
-    list(query = {}) {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections`, { query });
+        return new V1RuntimeConnectionResource(this.http, this.runtimeId, response);
     }
     delete(connectionId) {
         return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections/${encodeURIComponent(connectionId)}`, { method: 'DELETE' });
     }
 }
-export class V2RuntimeRunsClient {
+export class V1RuntimeRunsClient {
     http;
     runtimeId;
     constructor(http, runtimeId) {
@@ -59,10 +56,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,7 +97,7 @@ export class V2RuntimeFilesClient {
         });
     }
 }
-export class V2RuntimeResource {
+export class V1RuntimeResource {
     http;
     data;
     connections;
@@ -110,10 +107,10 @@ export class V2RuntimeResource {
     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.connections = new V1RuntimeConnectionsClient(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;
@@ -122,7 +119,7 @@ export class V2RuntimeResource {
         return this.data.activeRunId;
     }
     refresh() {
-        return new V2RuntimesClient(this.http).get(this.id);
+        return new V1RuntimesClient(this.http).get(this.id);
     }
     async connect(request) {
         return this.connections.create(request);
@@ -130,8 +127,8 @@ export class V2RuntimeResource {
     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),
         };
     }
     stop() {
@@ -147,7 +144,7 @@ export class V2RuntimeResource {
             });
         }
         const run = await this.http.request(`/runs/${encodeURIComponent(runtime.activeRunId)}`);
-        return new V2RunResource(this.http, run);
+        return new V1RunResource(this.http, run);
     }
 }
 function validateRuntimeCreateRequest(request) {
@@ -162,7 +159,7 @@ function validateRuntimeCreateRequest(request) {
         throw new BctrlValidationError('Only config.browser.profile and config.lifecycle 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 +168,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 +176,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 +184,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`, {

package/dist/spaces.d.ts

@@ -1,41 +1,40 @@
-import { V2SpaceBrowsersClient } from './browsers.js';
-import type { V2HttpClient } from './http.js';
-import { V2RuntimeResource, V2RuntimesClient } from './runtimes.js';
-import type { V2ListEnvelope, V2RuntimeListQuery, V2Space, V2SpaceCreateRequest, V2SpaceEnvironment, V2SpaceEnvironmentUpdateRequest, V2SpaceRuntimeCreateRequest, V2SpaceUpdateRequest } from './types.js';
-export declare class V2SpaceEnvironmentClient {
+import type { V1HttpClient } from './http.js';
+import { V1RuntimeResource, V1RuntimesClient } from './runtimes.js';
+import type { V1ListEnvelope, V1RuntimeListQuery, V1Space, V1SpaceCreateRequest, V1SpaceEnvironment, V1SpaceEnvironmentUpdateRequest, V1SpaceRuntimeCreateRequest, V1SpaceUpdateRequest } from './types.js';
+export declare class V1SpaceEnvironmentClient {
     private readonly http;
     private readonly spaceId;
-    constructor(http: V2HttpClient, spaceId: string);
-    get(): Promise<V2SpaceEnvironment>;
-    update(request: V2SpaceEnvironmentUpdateRequest): Promise<V2SpaceEnvironment>;
+    constructor(http: V1HttpClient, spaceId: string);
+    get(): Promise<V1SpaceEnvironment>;
+    update(request: V1SpaceEnvironmentUpdateRequest): Promise<V1SpaceEnvironment>;
 }
-export declare class V2SpaceRuntimesClient {
+export declare class V1SpaceRuntimesClient {
     private readonly http;
     private readonly spaceId;
-    constructor(http: V2HttpClient, spaceId: string);
-    list(query?: Omit<V2RuntimeListQuery, 'spaceId'>): ReturnType<V2RuntimesClient['list']>;
-    iter(query?: Omit<V2RuntimeListQuery, 'spaceId'>): ReturnType<V2RuntimesClient['iter']>;
-    create(request: V2SpaceRuntimeCreateRequest): Promise<V2RuntimeResource>;
-    get(runtimeId: string): Promise<V2RuntimeResource>;
-    stop(runtimeId: string): ReturnType<V2RuntimesClient['stop']>;
+    constructor(http: V1HttpClient, spaceId: string);
+    list(query?: Omit<V1RuntimeListQuery, 'spaceId'>): ReturnType<V1RuntimesClient['list']>;
+    iter(query?: Omit<V1RuntimeListQuery, 'spaceId'>): ReturnType<V1RuntimesClient['iter']>;
+    create(request: V1SpaceRuntimeCreateRequest): Promise<V1RuntimeResource>;
+    get(runtimeId: string): Promise<V1RuntimeResource>;
+    stop(runtimeId: string): ReturnType<V1RuntimesClient['stop']>;
+    start(runtimeId: string): ReturnType<V1RuntimesClient['start']>;
 }
-export declare class V2SpaceResource {
+export declare class V1SpaceResource {
     private readonly http;
-    readonly data: V2Space;
-    readonly environment: V2SpaceEnvironmentClient;
-    readonly runtimes: V2SpaceRuntimesClient;
-    readonly browsers: V2SpaceBrowsersClient;
-    constructor(http: V2HttpClient, data: V2Space);
+    readonly data: V1Space;
+    readonly environment: V1SpaceEnvironmentClient;
+    readonly runtimes: V1SpaceRuntimesClient;
+    constructor(http: V1HttpClient, data: V1Space);
     get id(): string;
-    refresh(): Promise<V2SpaceResource>;
-    update(request: V2SpaceUpdateRequest): Promise<V2SpaceResource>;
+    refresh(): Promise<V1SpaceResource>;
+    update(request: V1SpaceUpdateRequest): Promise<V1SpaceResource>;
 }
-export declare class V2SpacesClient {
+export declare class V1SpacesClient {
     private readonly http;
-    constructor(http: V2HttpClient);
-    list(): Promise<V2ListEnvelope<V2Space>>;
-    iter(): AsyncGenerator<V2Space, void, undefined>;
-    create(request: V2SpaceCreateRequest): Promise<V2SpaceResource>;
-    get(id: string): Promise<V2SpaceResource>;
-    update(id: string, request: V2SpaceUpdateRequest): Promise<V2SpaceResource>;
+    constructor(http: V1HttpClient);
+    list(): Promise<V1ListEnvelope<V1Space>>;
+    iter(): AsyncGenerator<V1Space, void, undefined>;
+    create(request: V1SpaceCreateRequest): Promise<V1SpaceResource>;
+    get(id: string): Promise<V1SpaceResource>;
+    update(id: string, request: V1SpaceUpdateRequest): Promise<V1SpaceResource>;
 }