@bctrl/sdk 1.0.9 → 1.0.11

package/dist/invocations.d.ts

@@ -1,125 +0,0 @@
-import { type V1HttpClient, type V1IdempotencyOptions } from './http.js';
-import { type JsonSchemaLike } from './schemas.js';
-import type { JsonObject, V1Invocation, V1RuntimeInvocationCreateRequest, V1RuntimeInvocationFileInput, V1RuntimeInvocationManagedTools, V1RuntimeTargetSelector, V1InvocationWaitRequest, V1InvocationWaitResponse, V1AiModelSelection } from './types.js';
-export type StagehandVariablePrimitive = string | number | boolean;
-export type StagehandVariableValue = StagehandVariablePrimitive | {
-    value: StagehandVariablePrimitive;
-    description?: string;
-};
-export type StagehandVariables = Record<string, StagehandVariableValue>;
-interface RuntimeInvocationCommonOptions {
-    target?: V1RuntimeTargetSelector;
-    metadata?: JsonObject;
-}
-interface RuntimeAgentCommonOptions extends RuntimeInvocationCommonOptions {
-    toolsetId?: string;
-    toolIds?: string[];
-    tools?: V1RuntimeInvocationManagedTools;
-    files?: V1RuntimeInvocationFileInput[];
-    schema?: JsonSchemaLike;
-    timeoutSeconds?: number;
-}
-interface AiSelectionOptions {
-    model?: V1AiModelSelection;
-    temperature?: number;
-}
-type StagehandActionInput = Extract<V1RuntimeInvocationCreateRequest, {
-    action: 'act';
-}>['stagehandAction'];
-export interface StagehandActOptions extends RuntimeInvocationCommonOptions, AiSelectionOptions {
-    instruction: string;
-    stagehandAction?: StagehandActionInput;
-    timeoutSeconds?: number;
-}
-export interface StagehandObserveOptions extends RuntimeInvocationCommonOptions, AiSelectionOptions {
-    instruction: string;
-    selector?: string;
-    timeoutSeconds?: number;
-}
-export type StagehandExtractOptions<TSchema extends JsonSchemaLike | undefined = undefined> = RuntimeInvocationCommonOptions & AiSelectionOptions & {
-    instruction?: string;
-    selector?: string;
-    schema?: TSchema;
-    timeoutSeconds?: number;
-};
-export interface StagehandAgentOptions extends RuntimeAgentCommonOptions, AiSelectionOptions {
-    instruction: string;
-    maxSteps?: number;
-    variables?: StagehandVariables;
-    executionModel?: V1AiModelSelection;
-    systemPrompt?: string;
-    highlightCursor?: boolean;
-}
-export interface BrowserUseAgentOptions extends RuntimeAgentCommonOptions, AiSelectionOptions {
-    instruction: string;
-    maxSteps?: number;
-    extractionModel?: V1AiModelSelection;
-    fallbackModel?: V1AiModelSelection;
-    useVision?: boolean | 'auto';
-    visionDetailLevel?: 'low' | 'high' | 'auto';
-    flashMode?: boolean;
-    enablePlanning?: boolean;
-    maxFailures?: number;
-    stepTimeoutSeconds?: number;
-    maxActionsPerStep?: number;
-    maxHistoryItems?: number | null;
-    useThinking?: boolean;
-    directlyOpenUrl?: boolean;
-    includeAttributes?: string[];
-    overrideSystemMessage?: string;
-    extendSystemMessage?: string;
-    sensitiveData?: Record<string, string | Record<string, string>>;
-}
-type InvocationCreateWithSchema<T extends V1RuntimeInvocationCreateRequest> = Omit<T, 'outputSchema'> & {
-    schema?: JsonSchemaLike;
-};
-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 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.
-     */
-    timeoutSeconds?: number;
-    /**
-     * Per-request long-poll timeout sent to the wait endpoint.
-     */
-    pollTimeoutSeconds?: number;
-    signal?: AbortSignal;
-}
-export declare class V1RuntimeInvocationsNamespaceClient {
-    private readonly http;
-    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 V1RuntimeStagehandInvocationsNamespaceClient {
-    private readonly invocations;
-    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 V1RuntimeBrowserUseInvocationsNamespaceClient {
-    private readonly invocations;
-    constructor(invocations: V1RuntimeInvocationsNamespaceClient);
-    agent(runtimeId: string, options: BrowserUseAgentOptions): Promise<V1Invocation>;
-}
-export {};

package/dist/invocations.js

@@ -1,199 +0,0 @@
-import { v1IdempotencyHeaders } from './http.js';
-import { toOutputSchema } from './schemas.js';
-import { abortableSleep } from './utils.js';
-// Live control is runtime-scoped; observability reads are run-scoped.
-function runtimeInvocationActionPath(runtimeId, invocationId, action) {
-    return `/runtimes/${encodeURIComponent(runtimeId)}/invocations/${encodeURIComponent(invocationId)}/${action}`;
-}
-function createRuntimeInvocation(http, runtimeId, request, options) {
-    return http.request(`/runtimes/${encodeURIComponent(runtimeId)}/invocations`, {
-        method: 'POST',
-        body: prepareInvocationCreateRequest(request),
-        headers: v1IdempotencyHeaders(options),
-    });
-}
-export class V1RuntimeInvocationsNamespaceClient {
-    http;
-    stagehand;
-    browserUse;
-    constructor(http) {
-        this.http = http;
-        this.stagehand = new V1RuntimeStagehandInvocationsNamespaceClient(this);
-        this.browserUse = new V1RuntimeBrowserUseInvocationsNamespaceClient(this);
-    }
-    create(runtimeId, request, options) {
-        return createRuntimeInvocation(this.http, runtimeId, request, options);
-    }
-    wait(runtimeId, invocationId, request = {}) {
-        return new V1RuntimeInvocationsClient(this.http, runtimeId).wait(invocationId, request);
-    }
-    cancel(runtimeId, invocationId) {
-        return new V1RuntimeInvocationsClient(this.http, runtimeId).cancel(invocationId);
-    }
-    createAndWait(runtimeId, request, options = {}) {
-        return new V1RuntimeInvocationsClient(this.http, runtimeId).createAndWait(request, options);
-    }
-}
-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, options) {
-        return createRuntimeInvocation(this.http, this.runtimeId, request, options);
-    }
-    wait(invocationId, request = {}) {
-        const { signal, ...body } = request;
-        return this.http.request(runtimeInvocationActionPath(this.runtimeId, invocationId, 'wait'), {
-            method: 'POST',
-            body,
-            signal,
-        });
-    }
-    cancel(invocationId) {
-        return this.http.request(runtimeInvocationActionPath(this.runtimeId, invocationId, 'cancel'), {
-            method: 'POST',
-        });
-    }
-    async createAndWait(request, options = {}) {
-        const invocation = await this.create(request, options);
-        return waitForInvocation(this, invocation.id, options);
-    }
-}
-class V1RuntimeStagehandInvocationsClient {
-    invocations;
-    constructor(invocations) {
-        this.invocations = invocations;
-    }
-    act(options) {
-        return this.invocations.create({
-            action: 'act',
-            ...options,
-        });
-    }
-    observe(options) {
-        return this.invocations.create({
-            action: 'observe',
-            ...options,
-        });
-    }
-    extract(options) {
-        const { schema, ...common } = options;
-        return this.invocations.create({
-            action: 'extract',
-            ...common,
-            ...(schema !== undefined
-                ? { outputSchema: toOutputSchema(schema, 'Stagehand extract schema') }
-                : {}),
-        });
-    }
-    agent(options) {
-        return this.invocations.create({
-            action: 'stagehandAgent',
-            ...options,
-        });
-    }
-}
-class V1RuntimeBrowserUseInvocationsClient {
-    invocations;
-    constructor(invocations) {
-        this.invocations = invocations;
-    }
-    agent(options) {
-        return this.invocations.create({
-            action: 'browserUse',
-            ...options,
-        });
-    }
-}
-export class V1RuntimeStagehandInvocationsNamespaceClient {
-    invocations;
-    constructor(invocations) {
-        this.invocations = invocations;
-    }
-    act(runtimeId, options) {
-        return this.invocations.create(runtimeId, {
-            action: 'act',
-            ...options,
-        });
-    }
-    observe(runtimeId, options) {
-        return this.invocations.create(runtimeId, {
-            action: 'observe',
-            ...options,
-        });
-    }
-    extract(runtimeId, options) {
-        const { schema, ...common } = options;
-        return this.invocations.create(runtimeId, {
-            action: 'extract',
-            ...common,
-            ...(schema !== undefined
-                ? { outputSchema: toOutputSchema(schema, 'Stagehand extract schema') }
-                : {}),
-        });
-    }
-    agent(runtimeId, options) {
-        return this.invocations.create(runtimeId, {
-            action: 'stagehandAgent',
-            ...options,
-        });
-    }
-}
-export class V1RuntimeBrowserUseInvocationsNamespaceClient {
-    invocations;
-    constructor(invocations) {
-        this.invocations = invocations;
-    }
-    agent(runtimeId, options) {
-        return this.invocations.create(runtimeId, {
-            action: 'browserUse',
-            ...options,
-        });
-    }
-}
-function prepareInvocationCreateRequest(request) {
-    if (!hasInvocationSchema(request)) {
-        return request;
-    }
-    const { schema, ...body } = request;
-    return {
-        ...body,
-        outputSchema: toOutputSchema(schema, 'Invocation schema'),
-    };
-}
-function hasInvocationSchema(request) {
-    return 'schema' in request && request.schema !== undefined;
-}
-async function waitForInvocation(client, invocationId, options) {
-    const deadline = options.timeoutSeconds === undefined ? undefined : Date.now() + options.timeoutSeconds * 1000;
-    for (;;) {
-        if (deadline !== undefined && Date.now() >= deadline) {
-            throw new Error(`Invocation ${invocationId} did not finish before timeout`);
-        }
-        const remainingMs = deadline === undefined ? undefined : Math.max(1, deadline - Date.now());
-        const remainingSeconds = remainingMs === undefined ? undefined : Math.max(1, Math.ceil(remainingMs / 1000));
-        const timeoutSeconds = options.pollTimeoutSeconds === undefined
-            ? remainingSeconds
-            : remainingSeconds === undefined
-                ? options.pollTimeoutSeconds
-                : Math.min(options.pollTimeoutSeconds, remainingSeconds);
-        const result = await client.wait(invocationId, {
-            ...(timeoutSeconds === undefined ? {} : { timeoutSeconds }),
-            signal: options.signal,
-        });
-        if (result.waitStatus === 'completed') {
-            return result;
-        }
-        const sleepMs = deadline === undefined
-            ? (result.retryAfterSeconds ?? 1) * 1000
-            : Math.min((result.retryAfterSeconds ?? 1) * 1000, Math.max(0, deadline - Date.now()));
-        await abortableSleep(sleepMs, options.signal);
-    }
-}

package/dist/vault.d.ts

@@ -1,14 +0,0 @@
-import type { V1HttpClient } from './http.js';
-import type { V1ListEnvelope, V1VaultSecret, V1VaultSecretDeleteResponse, V1VaultSecretListQuery, V1VaultSecretPatchRequest, V1VaultSecretUpsertRequest, V1VaultSecretValue, V1VaultTotpResponse } from './types.js';
-export declare class V1VaultClient {
-    private readonly http;
-    constructor(http: V1HttpClient);
-    list(query?: V1VaultSecretListQuery): Promise<V1ListEnvelope<V1VaultSecret>>;
-    iter(query?: V1VaultSecretListQuery): AsyncGenerator<V1VaultSecret, void, undefined>;
-    get(key: string): Promise<V1VaultSecret>;
-    value(key: string): Promise<V1VaultSecretValue>;
-    upsert(key: string, request: V1VaultSecretUpsertRequest): Promise<V1VaultSecret>;
-    update(key: string, request: V1VaultSecretPatchRequest): Promise<V1VaultSecret>;
-    totp(key: string): Promise<V1VaultTotpResponse>;
-    delete(key: string): Promise<V1VaultSecretDeleteResponse>;
-}

package/dist/vault.js

@@ -1,37 +0,0 @@
-import { iterateV1Pages } from './pagination.js';
-export class V1VaultClient {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    list(query = {}) {
-        return this.http.request('/vault/secrets', { query });
-    }
-    iter(query = {}) {
-        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
-    }
-    get(key) {
-        return this.http.request(`/vault/secrets/${encodeURIComponent(key)}`);
-    }
-    value(key) {
-        return this.http.request(`/vault/secrets/${encodeURIComponent(key)}/value`);
-    }
-    upsert(key, request) {
-        return this.http.request(`/vault/secrets/${encodeURIComponent(key)}`, {
-            method: 'PUT',
-            body: request,
-        });
-    }
-    update(key, request) {
-        return this.http.request(`/vault/secrets/${encodeURIComponent(key)}`, {
-            method: 'PATCH',
-            body: request,
-        });
-    }
-    totp(key) {
-        return this.http.request(`/vault/secrets/${encodeURIComponent(key)}/totp`);
-    }
-    delete(key) {
-        return this.http.request(`/vault/secrets/${encodeURIComponent(key)}`, { method: 'DELETE' });
-    }
-}

package/dist/vaultTypes.d.ts

@@ -1,9 +0,0 @@
-import type { OpenApiQuery, OpenApiSchemas } from './openapi.js';
-export type V1VaultSecretType = OpenApiSchemas['VaultSecret']['type'];
-export type V1VaultSecret = OpenApiSchemas['VaultSecret'];
-export type V1VaultSecretListQuery = OpenApiQuery<'vault.secrets.list'>;
-export type V1VaultSecretUpsertRequest = OpenApiSchemas['VaultSecretUpsertRequest'];
-export type V1VaultSecretPatchRequest = OpenApiSchemas['VaultSecretPatchRequest'];
-export type V1VaultSecretValue = OpenApiSchemas['VaultSecretValue'];
-export type V1VaultTotpResponse = OpenApiSchemas['VaultTotpResponse'];
-export type V1VaultSecretDeleteResponse = OpenApiSchemas['VaultSecretDeleteResponse'];