@bctrl/sdk 1.0.4 → 1.0.5

package/dist/files.d.ts

@@ -1,31 +1,13 @@
 import type { V1HttpClient } from './http.js';
-import type { V1File, V1FileDeleteResponse, V1FilesListQuery, V1FileUpdateRequest, V1FileUploadRequest, V1ListEnvelope, V1RunFilesExportRequest, V1RunFilesListQuery } from './types.js';
-export declare class V1FileResource {
-    private readonly http;
-    readonly data: V1File;
-    constructor(http: V1HttpClient, data: V1File);
-    get id(): string;
-    refresh(): Promise<V1FileResource>;
-    content(): Promise<Response>;
-    update(request: V1FileUpdateRequest): Promise<V1FileResource>;
-    delete(): Promise<V1FileDeleteResponse>;
-}
+import type { V1File, V1FileDeleteResponse, V1FilesListQuery, V1FileUpdateRequest, V1FileUploadRequest, V1ListEnvelope } from './types.js';
 export declare class V1FilesClient {
     private readonly http;
     constructor(http: V1HttpClient);
-    list(query: V1FilesListQuery): Promise<V1ListEnvelope<V1File>>;
-    iter(query: V1FilesListQuery): AsyncGenerator<V1File, void, undefined>;
-    get(id: string): Promise<V1FileResource>;
-    update(id: string, request: V1FileUpdateRequest): Promise<V1FileResource>;
+    list(query?: V1FilesListQuery): Promise<V1ListEnvelope<V1File>>;
+    iter(query?: V1FilesListQuery): AsyncGenerator<V1File, void, undefined>;
+    get(id: string): Promise<V1File>;
+    update(id: string, request: V1FileUpdateRequest): Promise<V1File>;
     content(id: string): Promise<Response>;
     delete(id: string): Promise<V1FileDeleteResponse>;
-    upload(request: V1FileUploadRequest): Promise<V1FileResource>;
-}
-export declare class V1RunFilesClient {
-    private readonly http;
-    private readonly runId;
-    constructor(http: V1HttpClient, runId: string);
-    list(query?: V1RunFilesListQuery): Promise<V1ListEnvelope<V1File>>;
-    iter(query?: V1RunFilesListQuery): AsyncGenerator<V1File, void, undefined>;
-    export(request: V1RunFilesExportRequest): Promise<V1FileResource>;
+    upload(request: V1FileUploadRequest): Promise<V1File>;
 }

package/dist/files.js

@@ -1,48 +1,23 @@
 import { iterateV1Pages } from './pagination.js';
-export class V1FileResource {
-    http;
-    data;
-    constructor(http, data) {
-        this.http = http;
-        this.data = data;
-    }
-    get id() {
-        return this.data.id;
-    }
-    refresh() {
-        return new V1FilesClient(this.http).get(this.id);
-    }
-    async content() {
-        return new V1FilesClient(this.http).content(this.id);
-    }
-    async update(request) {
-        return new V1FilesClient(this.http).update(this.id, request);
-    }
-    delete() {
-        return new V1FilesClient(this.http).delete(this.id);
-    }
-}
 export class V1FilesClient {
     http;
     constructor(http) {
         this.http = http;
     }
-    list(query) {
+    list(query = {}) {
         return this.http.request('/files', { query });
     }
-    iter(query) {
+    iter(query = {}) {
         return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
-    async get(id) {
-        const file = await this.http.request(`/files/${encodeURIComponent(id)}`);
-        return new V1FileResource(this.http, file);
+    get(id) {
+        return this.http.request(`/files/${encodeURIComponent(id)}`);
     }
-    async update(id, request) {
-        const file = await this.http.request(`/files/${encodeURIComponent(id)}`, {
+    update(id, request) {
+        return this.http.request(`/files/${encodeURIComponent(id)}`, {
             method: 'PATCH',
             body: request,
         });
-        return new V1FileResource(this.http, file);
     }
     content(id) {
         return this.http.raw(`/files/${encodeURIComponent(id)}/content`);
@@ -52,7 +27,7 @@ export class V1FilesClient {
             method: 'DELETE',
         });
     }
-    async upload(request) {
+    upload(request) {
         const form = new FormData();
         if (request.name) {
             form.set('file', request.file, request.name);
@@ -66,32 +41,10 @@ export class V1FilesClient {
             form.set('path', request.path);
         if (request.metadata)
             form.set('metadata', JSON.stringify(request.metadata));
-        const file = await this.http.request('/files', {
+        return this.http.request('/files', {
             method: 'POST',
-            query: { spaceId: request.spaceId },
+            query: request.spaceId ? { spaceId: request.spaceId } : undefined,
             body: form,
         });
-        return new V1FileResource(this.http, file);
-    }
-}
-export class V1RunFilesClient {
-    http;
-    runId;
-    constructor(http, runId) {
-        this.http = http;
-        this.runId = runId;
-    }
-    list(query = {}) {
-        return this.http.request(`/runs/${encodeURIComponent(this.runId)}/files`, { query });
-    }
-    iter(query = {}) {
-        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
-    }
-    async export(request) {
-        const file = await this.http.request(`/runs/${encodeURIComponent(this.runId)}/files/export`, {
-            method: 'POST',
-            body: request,
-        });
-        return new V1FileResource(this.http, file);
     }
 }

package/dist/help.d.ts

@@ -0,0 +1,7 @@
+import type { V1HttpClient } from './http.js';
+import type { V1HelpRequest, V1HelpResponse } from './types.js';
+export declare class V1HelpClient {
+    private readonly http;
+    constructor(http: V1HttpClient);
+    get(request?: V1HelpRequest): Promise<V1HelpResponse>;
+}

package/dist/help.js

@@ -0,0 +1,9 @@
+export class V1HelpClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    get(request = {}) {
+        return this.http.request('/help', { query: request });
+    }
+}

package/dist/http.d.ts

@@ -1,18 +1,29 @@
 export interface V1ClientOptions {
     apiKey?: string;
     baseUrl?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    fetch?: typeof fetch;
 }
 export interface V1RequestOptions {
-    method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
     query?: object;
     body?: unknown;
     headers?: Record<string, string>;
     timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface V1IdempotencyOptions {
+    idempotencyKey?: string;
 }
 export declare class V1HttpClient {
     readonly baseUrl: string;
     readonly apiKey: string;
+    private readonly timeoutMs?;
+    private readonly maxRetries;
+    private readonly fetchImpl;
     constructor(options: V1ClientOptions);
     request<T>(path: string, options?: V1RequestOptions): Promise<T>;
     raw(path: string, options?: V1RequestOptions): Promise<Response>;
 }
+export declare function v1IdempotencyHeaders(options?: V1IdempotencyOptions): Record<string, string> | undefined;

package/dist/http.js

@@ -1,5 +1,5 @@
 import { BctrlNetworkError, createV1HttpError } from './errors.js';
-import { BCTRL_PRODUCTION_ORIGIN, fetchWithTimeout, resolveApiKey, stripTrailingSlash, } from './utils.js';
+import { BCTRL_PRODUCTION_ORIGIN, abortableSleep, fetchWithTimeout, resolveApiKey, stripTrailingSlash, } from './utils.js';
 import { SDK_VERSION } from './version.js';
 const API_PREFIX = '/v1';
 function resolveV1ApiBaseUrl(baseUrl) {
@@ -43,9 +43,7 @@ function parseResponseBody(text) {
     }
 }
 function responseRequestId(response) {
-    return (response.headers.get('x-request-id') ??
-        response.headers.get('x-bctrl-request-id') ??
-        undefined);
+    return (response.headers.get('x-request-id') ?? response.headers.get('x-bctrl-request-id') ?? undefined);
 }
 function isRecord(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
@@ -73,9 +71,15 @@ function isBodyInit(value) {
 export class V1HttpClient {
     baseUrl;
     apiKey;
+    timeoutMs;
+    maxRetries;
+    fetchImpl;
     constructor(options) {
         this.baseUrl = resolveV1ApiBaseUrl(options.baseUrl);
         this.apiKey = resolveV1ApiKey(options.apiKey);
+        this.timeoutMs = options.timeoutMs;
+        this.maxRetries = options.maxRetries ?? 2;
+        this.fetchImpl = options.fetch ?? fetch;
     }
     async request(path, options = {}) {
         const response = await this.raw(path, options);
@@ -95,8 +99,9 @@ export class V1HttpClient {
             'User-Agent': `@bctrl/sdk/${SDK_VERSION} v1`,
             ...options.headers,
         };
+        const method = options.method ?? 'GET';
         const init = {
-            method: options.method ?? 'GET',
+            method,
             headers,
         };
         if (options.body !== undefined) {
@@ -109,12 +114,32 @@ export class V1HttpClient {
             }
         }
         let response;
-        try {
-            response = await fetchWithTimeout(url.toString(), init, options.timeoutMs);
+        let lastNetworkError;
+        const maxAttempts = canRetryRequest(method, headers) ? Math.max(1, this.maxRetries + 1) : 1;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                response = await fetchWithTimeout(url.toString(), { ...init, signal: options.signal }, options.timeoutMs ?? this.timeoutMs, this.fetchImpl);
+            }
+            catch (error) {
+                lastNetworkError = error;
+                if (attempt < maxAttempts && isRetryableNetworkError(error)) {
+                    await abortableSleep(retryDelayMs(attempt), options.signal);
+                    continue;
+                }
+                if (error instanceof Error) {
+                    throw new BctrlNetworkError(error.message, { cause: error });
+                }
+                throw new BctrlNetworkError('Network request failed');
+            }
+            if (response.ok || !isRetryableStatus(response.status) || attempt >= maxAttempts) {
+                break;
+            }
+            await response.body?.cancel().catch(() => undefined);
+            await abortableSleep(retryAfterMs(response) ?? retryDelayMs(attempt), options.signal);
         }
-        catch (error) {
-            if (error instanceof Error) {
-                throw new BctrlNetworkError(error.message, { cause: error });
+        if (!response) {
+            if (lastNetworkError instanceof Error) {
+                throw new BctrlNetworkError(lastNetworkError.message, { cause: lastNetworkError });
             }
             throw new BctrlNetworkError('Network request failed');
         }
@@ -133,3 +158,41 @@ export class V1HttpClient {
         return response;
     }
 }
+function isRetryableStatus(status) {
+    return status === 408 || status === 429 || status >= 500;
+}
+function canRetryRequest(method, headers) {
+    const normalized = method.toUpperCase();
+    if (normalized === 'GET' || normalized === 'HEAD' || normalized === 'OPTIONS') {
+        return true;
+    }
+    return hasHeader(headers, 'Idempotency-Key');
+}
+function hasHeader(headers, name) {
+    const expected = name.toLowerCase();
+    return Object.entries(headers).some(([key, value]) => key.toLowerCase() === expected && value.trim().length > 0);
+}
+function isRetryableNetworkError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return error.name === 'AbortError' || error.name === 'TimeoutError';
+}
+function retryAfterMs(response) {
+    const raw = response.headers.get('retry-after');
+    if (!raw)
+        return undefined;
+    const seconds = Number(raw);
+    if (Number.isFinite(seconds))
+        return Math.max(0, seconds * 1000);
+    const date = Date.parse(raw);
+    if (Number.isFinite(date))
+        return Math.max(0, date - Date.now());
+    return undefined;
+}
+function retryDelayMs(attempt) {
+    return Math.min(2000, 250 * 2 ** Math.max(0, attempt - 1));
+}
+export function v1IdempotencyHeaders(options) {
+    const key = options?.idempotencyKey?.trim();
+    return key ? { 'Idempotency-Key': key } : undefined;
+}

package/dist/index.d.ts

@@ -1,9 +1,20 @@
 export { Bctrl, BctrlV1, type BctrlV1Options } from './bctrl.js';
+export { V1AccountClient, V1ApiKeysClient, V1AuthClient, V1SubaccountsClient, V1SubaccountUsageClient, V1UsageClient, } from './account.js';
+export { V1AiProvidersClient } from './aiProviders.js';
+export { V1BrowserExtensionsClient } from './browserExtensions.js';
 export { BctrlError, BctrlApiError, BctrlAuthenticationError, BctrlConflictError, BctrlNetworkError, BctrlNotFoundError, BctrlNotReadyError, BctrlPermissionError, BctrlRateLimitError, BctrlUnsupportedError, BctrlValidationError, isControllerBusy, } from './errors.js';
-export { V1FileResource, V1FilesClient, V1RunFilesClient } from './files.js';
-export { V1InvocationsClient, V1InvocationResource, V1RuntimeBrowserUseInvocationsClient, V1RuntimeInvocationsClient, V1RuntimeStagehandInvocationsClient, } from './invocations.js';
-export type { BrowserUseAgentOptions, StagehandActOptions, StagehandAgentOptions, StagehandExtractOptions, StagehandObserveOptions, StagehandVariablePrimitive, StagehandVariableValue, StagehandVariables, } from './invocations.js';
-export { V1RuntimeFilesClient, V1RuntimeResource, V1RuntimeRunsClient, V1RuntimesClient, } from './runtimes.js';
-export { V1RunCommandsClient, V1RunEventsClient, V1RunResource, V1RunsClient } from './runs.js';
-export { V1SpaceEnvironmentClient, V1SpaceResource, V1SpaceRuntimesClient, V1SpacesClient, } from './spaces.js';
+export { V1FilesClient } from './files.js';
+export { V1HelpClient } from './help.js';
+export { V1RuntimeBrowserUseInvocationsNamespaceClient, V1RuntimeInvocationsNamespaceClient, V1RuntimeStagehandInvocationsNamespaceClient, } from './invocations.js';
+export type { BrowserUseAgentOptions, V1InvocationCreateAndWaitOptions, V1InvocationWaitOptions, V1RuntimeInvocationCreateInput, StagehandActOptions, StagehandAgentOptions, StagehandExtractOptions, StagehandObserveOptions, StagehandVariablePrimitive, StagehandVariableValue, StagehandVariables, } from './invocations.js';
+export { V1RuntimeFilesNamespaceClient, V1RuntimeRunsNamespaceClient, V1RuntimesClient, } from './runtimes.js';
+export { V1ProxiesClient, V1ProxyPoolsClient } from './proxies.js';
+export { V1RunActivityNamespaceClient, V1RunEventsNamespaceClient, V1RunFilesNamespaceClient, V1RunInvocationsNamespaceClient, V1RunsClient, } from './runs.js';
+export { toOutputSchema, type JsonSchemaLike, type JsonSchemaObject } from './schemas.js';
+export { V1SpaceEnvironmentNamespaceClient, V1SpaceRuntimesNamespaceClient, V1SpacesClient, } from './spaces.js';
+export { V1ToolCallsClient } from './toolCalls.js';
+export { passthroughJsonSchema, V1ToolsClient } from './tools.js';
+export { V1ToolsetsClient } from './toolsets.js';
+export { V1VaultClient } from './vault.js';
 export type * from './types.js';
+export type * from './browserExtensionTypes.js';

package/dist/index.js

@@ -1,7 +1,17 @@
 export { Bctrl, BctrlV1 } from './bctrl.js';
+export { V1AccountClient, V1ApiKeysClient, V1AuthClient, V1SubaccountsClient, V1SubaccountUsageClient, V1UsageClient, } from './account.js';
+export { V1AiProvidersClient } from './aiProviders.js';
+export { V1BrowserExtensionsClient } from './browserExtensions.js';
 export { BctrlError, BctrlApiError, BctrlAuthenticationError, BctrlConflictError, BctrlNetworkError, BctrlNotFoundError, BctrlNotReadyError, BctrlPermissionError, BctrlRateLimitError, BctrlUnsupportedError, BctrlValidationError, isControllerBusy, } from './errors.js';
-export { V1FileResource, V1FilesClient, V1RunFilesClient } from './files.js';
-export { V1InvocationsClient, V1InvocationResource, V1RuntimeBrowserUseInvocationsClient, V1RuntimeInvocationsClient, V1RuntimeStagehandInvocationsClient, } from './invocations.js';
-export { V1RuntimeFilesClient, V1RuntimeResource, V1RuntimeRunsClient, V1RuntimesClient, } from './runtimes.js';
-export { V1RunCommandsClient, V1RunEventsClient, V1RunResource, V1RunsClient } from './runs.js';
-export { V1SpaceEnvironmentClient, V1SpaceResource, V1SpaceRuntimesClient, V1SpacesClient, } from './spaces.js';
+export { V1FilesClient } from './files.js';
+export { V1HelpClient } from './help.js';
+export { V1RuntimeBrowserUseInvocationsNamespaceClient, V1RuntimeInvocationsNamespaceClient, V1RuntimeStagehandInvocationsNamespaceClient, } from './invocations.js';
+export { V1RuntimeFilesNamespaceClient, V1RuntimeRunsNamespaceClient, V1RuntimesClient, } from './runtimes.js';
+export { V1ProxiesClient, V1ProxyPoolsClient } from './proxies.js';
+export { V1RunActivityNamespaceClient, V1RunEventsNamespaceClient, V1RunFilesNamespaceClient, V1RunInvocationsNamespaceClient, V1RunsClient, } from './runs.js';
+export { toOutputSchema } from './schemas.js';
+export { V1SpaceEnvironmentNamespaceClient, V1SpaceRuntimesNamespaceClient, V1SpacesClient, } from './spaces.js';
+export { V1ToolCallsClient } from './toolCalls.js';
+export { passthroughJsonSchema, V1ToolsClient } from './tools.js';
+export { V1ToolsetsClient } from './toolsets.js';
+export { V1VaultClient } from './vault.js';

package/dist/invocations.d.ts

@@ -1,8 +1,6 @@
-import type { V1HttpClient } from './http.js';
-import type { JsonObject, V1Invocation, V1RuntimeInvocationCreateRequest, V1RuntimeInvocationFileInput, V1InvocationWaitRequest, V1InvocationWaitResponse } from './types.js';
-type JsonSchemaLike = JsonObject | {
-    toJSONSchema: () => unknown;
-};
+import { type V1HttpClient, type V1IdempotencyOptions } from './http.js';
+import { type JsonSchemaLike } from './schemas.js';
+import type { JsonObject, V1Invocation, V1InvocationPage, V1RuntimeInvocationCreateRequest, V1RuntimeInvocationFileInput, V1InvocationWaitRequest, V1InvocationWaitResponse } from './types.js';
 export type StagehandVariablePrimitive = string | number | boolean;
 export type StagehandVariableValue = StagehandVariablePrimitive | {
     value: StagehandVariablePrimitive;
@@ -10,77 +8,117 @@ export type StagehandVariableValue = StagehandVariablePrimitive | {
 };
 export type StagehandVariables = Record<string, StagehandVariableValue>;
 interface RuntimeInvocationCommonOptions {
-    target?: JsonObject;
-    idempotencyKey?: string;
+    page?: V1InvocationPage;
     metadata?: JsonObject;
 }
 interface RuntimeAgentCommonOptions extends RuntimeInvocationCommonOptions {
     toolsetId?: string;
+    toolIds?: string[];
     files?: V1RuntimeInvocationFileInput[];
+    schema?: JsonSchemaLike;
     outputSchema?: JsonObject;
+    timeoutMs?: number;
 }
-export interface StagehandActOptions extends RuntimeInvocationCommonOptions {
+interface AiSelectionOptions {
+    aiProviderId?: string;
+    model?: string;
+    temperature?: number;
+}
+export interface StagehandActOptions extends RuntimeInvocationCommonOptions, AiSelectionOptions {
     instruction: string;
+    stagehandAction?: JsonObject;
     timeoutMs?: number;
 }
-export interface StagehandObserveOptions extends RuntimeInvocationCommonOptions {
+export interface StagehandObserveOptions extends RuntimeInvocationCommonOptions, AiSelectionOptions {
     instruction: string;
     selector?: string;
     timeoutMs?: number;
 }
-export type StagehandExtractOptions<TSchema extends JsonSchemaLike | undefined = undefined> = RuntimeInvocationCommonOptions & {
-    instruction: string;
+export type StagehandExtractOptions<TSchema extends JsonSchemaLike | undefined = undefined> = RuntimeInvocationCommonOptions & AiSelectionOptions & {
+    instruction?: string;
+    selector?: string;
     schema?: TSchema;
+    timeoutMs?: number;
 };
-export interface StagehandAgentOptions extends RuntimeAgentCommonOptions {
+export interface StagehandAgentOptions extends RuntimeAgentCommonOptions, AiSelectionOptions {
     instruction: string;
     maxSteps?: number;
-    timeoutMs?: number;
     variables?: StagehandVariables;
-    config?: JsonObject;
-    options?: JsonObject;
+    executionAiProviderId?: string;
+    systemPrompt?: string;
+    highlightCursor?: boolean;
 }
-export interface BrowserUseAgentOptions extends RuntimeAgentCommonOptions {
+export interface BrowserUseAgentOptions extends RuntimeAgentCommonOptions, AiSelectionOptions {
     instruction: string;
     maxSteps?: number;
-    config?: JsonObject;
-    options?: JsonObject;
+    extractionAiProviderId?: string;
+    fallbackAiProviderId?: string;
+    useVision?: boolean | 'auto';
+    visionDetailLevel?: 'low' | 'high' | 'auto';
+    flashMode?: boolean;
+    enablePlanning?: boolean;
+    maxFailures?: number;
+    stepTimeoutMs?: number;
+    maxActionsPerStep?: number;
+    maxHistoryItems?: number | null;
+    useThinking?: boolean;
+    directlyOpenUrl?: boolean;
+    includeAttributes?: string[];
+    overrideSystemMessage?: string;
+    extendSystemMessage?: string;
+    sensitiveData?: Record<string, string | Record<string, string>>;
 }
-export declare class V1InvocationResource {
-    private readonly http;
-    readonly data: V1Invocation;
-    constructor(http: V1HttpClient, data: V1Invocation);
-    get id(): string;
-    refresh(): Promise<V1Invocation>;
-    wait(request?: V1InvocationWaitRequest): Promise<V1InvocationWaitResponse>;
-    cancel(): Promise<V1Invocation>;
+type InvocationCreateWithSchema<T extends V1RuntimeInvocationCreateRequest> = Omit<T, 'outputSchema'> & {
+    schema?: JsonSchemaLike;
+    outputSchema?: JsonObject;
+};
+type ExtractInvocationCreateRequest = Extract<V1RuntimeInvocationCreateRequest, {
+    action: 'extract';
+}>;
+type StagehandAgentInvocationCreateRequest = Extract<V1RuntimeInvocationCreateRequest, {
+    action: 'stagehandAgent';
+}>;
+type BrowserUseInvocationCreateRequest = Extract<V1RuntimeInvocationCreateRequest, {
+    action: 'browserUse';
+}>;
+type InvocationCreateSchemaInput = InvocationCreateWithSchema<ExtractInvocationCreateRequest> | InvocationCreateWithSchema<StagehandAgentInvocationCreateRequest> | InvocationCreateWithSchema<BrowserUseInvocationCreateRequest>;
+export type V1RuntimeInvocationCreateInput = Exclude<V1RuntimeInvocationCreateRequest, ExtractInvocationCreateRequest | StagehandAgentInvocationCreateRequest | BrowserUseInvocationCreateRequest> | InvocationCreateSchemaInput;
+export interface V1InvocationWaitOptions extends V1InvocationWaitRequest {
+    signal?: AbortSignal;
 }
-export declare class V1InvocationsClient {
-    private readonly http;
-    constructor(http: V1HttpClient);
-    get(id: string): Promise<V1InvocationResource>;
-    wait(id: string, request?: V1InvocationWaitRequest): Promise<V1InvocationWaitResponse>;
-    cancel(id: string): Promise<V1InvocationResource>;
+export interface V1InvocationCreateAndWaitOptions extends V1IdempotencyOptions {
+    /**
+     * Overall client-side wait budget across repeated long-poll requests.
+     * The server-side invocation timeout still belongs in the invocation body.
+     */
+    timeoutMs?: number;
+    /**
+     * Per-request long-poll timeout sent to the wait endpoint.
+     */
+    pollTimeoutMs?: number;
+    signal?: AbortSignal;
 }
-export declare class V1RuntimeInvocationsClient {
+export declare class V1RuntimeInvocationsNamespaceClient {
     private readonly http;
-    private readonly runtimeId;
-    readonly stagehand: V1RuntimeStagehandInvocationsClient;
-    readonly browserUse: V1RuntimeBrowserUseInvocationsClient;
-    constructor(http: V1HttpClient, runtimeId: string);
-    create(request: V1RuntimeInvocationCreateRequest): Promise<V1InvocationResource>;
+    readonly stagehand: V1RuntimeStagehandInvocationsNamespaceClient;
+    readonly browserUse: V1RuntimeBrowserUseInvocationsNamespaceClient;
+    constructor(http: V1HttpClient);
+    create(runtimeId: string, request: V1RuntimeInvocationCreateInput, options?: V1IdempotencyOptions): Promise<V1Invocation>;
+    wait(runtimeId: string, invocationId: string, request?: V1InvocationWaitOptions): Promise<V1InvocationWaitResponse>;
+    cancel(runtimeId: string, invocationId: string): Promise<V1Invocation>;
+    createAndWait(runtimeId: string, request: V1RuntimeInvocationCreateInput, options?: V1InvocationCreateAndWaitOptions): Promise<V1Invocation>;
 }
-export declare class V1RuntimeStagehandInvocationsClient {
+export declare class V1RuntimeStagehandInvocationsNamespaceClient {
     private readonly invocations;
-    constructor(invocations: V1RuntimeInvocationsClient);
-    act(options: StagehandActOptions): Promise<V1InvocationResource>;
-    observe(options: StagehandObserveOptions): Promise<V1InvocationResource>;
-    extract<TSchema extends JsonSchemaLike | undefined = undefined>(options: StagehandExtractOptions<TSchema>): Promise<V1InvocationResource>;
-    agent(options: StagehandAgentOptions): Promise<V1InvocationResource>;
+    constructor(invocations: V1RuntimeInvocationsNamespaceClient);
+    act(runtimeId: string, options: StagehandActOptions): Promise<V1Invocation>;
+    observe(runtimeId: string, options: StagehandObserveOptions): Promise<V1Invocation>;
+    extract<TSchema extends JsonSchemaLike | undefined = undefined>(runtimeId: string, options: StagehandExtractOptions<TSchema>): Promise<V1Invocation>;
+    agent(runtimeId: string, options: StagehandAgentOptions): Promise<V1Invocation>;
 }
-export declare class V1RuntimeBrowserUseInvocationsClient {
+export declare class V1RuntimeBrowserUseInvocationsNamespaceClient {
     private readonly invocations;
-    constructor(invocations: V1RuntimeInvocationsClient);
-    agent(options: BrowserUseAgentOptions): Promise<V1InvocationResource>;
+    constructor(invocations: V1RuntimeInvocationsNamespaceClient);
+    agent(runtimeId: string, options: BrowserUseAgentOptions): Promise<V1Invocation>;
 }
 export {};