@bctrl/sdk 1.0.4 → 1.0.6

package/dist/runtimes.js

@@ -1,8 +1,8 @@
 import { BctrlValidationError } from './errors.js';
-import { V1RuntimeInvocationsClient } from './invocations.js';
+import { v1IdempotencyHeaders } from './http.js';
+import { V1RuntimeInvocationsNamespaceClient } from './invocations.js';
 import { iterateV1Pages } from './pagination.js';
-import { V1RunResource } from './runs.js';
-export class V1RuntimeRunsClient {
+class V1RuntimeRunsClient {
     http;
     runtimeId;
     constructor(http, runtimeId) {
@@ -16,13 +16,19 @@ export class V1RuntimeRunsClient {
         return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
 }
-export class V1RuntimeFilesClient {
+class V1RuntimeFilesClient {
     http;
     runtimeId;
     constructor(http, runtimeId) {
         this.http = http;
         this.runtimeId = runtimeId;
     }
+    list(query = {}) {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/files`, { query });
+    }
+    iter(query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
+    }
     async upload(request) {
         const form = new FormData();
         if (request.name) {
@@ -32,8 +38,10 @@ export class V1RuntimeFilesClient {
         else {
             form.set('file', request.file);
         }
-        if (request.storagePath)
-            form.set('storagePath', request.storagePath);
+        if (request.destinationPath)
+            form.set('destinationPath', request.destinationPath);
+        if (request.runtimePath)
+            form.set('runtimePath', request.runtimePath);
         if (request.metadata)
             form.set('metadata', JSON.stringify(request.metadata));
         return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/files/upload`, {
@@ -54,69 +62,53 @@ export class V1RuntimeFilesClient {
         });
     }
 }
-export class V1RuntimeResource {
+class V1RuntimeTargetsClient {
     http;
-    data;
-    files;
-    runs;
-    invocations;
-    constructor(http, data) {
+    runtimeId;
+    constructor(http, runtimeId) {
         this.http = http;
-        this.data = data;
-        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 'activeRunId' in this.data ? this.data.activeRunId : null;
-    }
-    refresh() {
-        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 V1RuntimeResource(this.http, response.runtime),
-            run: new V1RunResource(this.http, response.run),
-            browser: response.browser,
-        };
-    }
-    stop() {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.id)}/stop`, {
+        this.runtimeId = runtimeId;
+    }
+    list() {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/targets`);
+    }
+    create(request = {}) {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/targets`, {
             method: 'POST',
+            body: request,
         });
     }
-    async run() {
-        const runtime = await this.refresh();
-        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(activeRunId)}`);
-        return new V1RunResource(this.http, run);
+    get(targetId) {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/targets/${encodeURIComponent(targetId)}`);
+    }
+    activate(targetId) {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/targets/${encodeURIComponent(targetId)}/activate`, { method: 'POST' });
+    }
+    delete(targetId) {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/targets/${encodeURIComponent(targetId)}`, { method: 'DELETE' });
     }
 }
 function validateRuntimeCreateRequest(request) {
     const profileBacked = request.config?.profile === true;
     if (!profileBacked)
         return;
-    if (!request.name?.trim()) {
-        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);
+    const unsupported = ['stealth', 'fingerprint', 'extensionIds'].filter((key) => request.config?.[key] !== undefined);
     if (unsupported.length > 0) {
-        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 });
+        throw new BctrlValidationError('Only config.profile, config.proxy, config.autoUpgrade, config.idleTimeoutMinutes, config.webRtcProxyOnly, config.forceOpenShadowRoots, and config.networkTraffic are supported for profile-backed browser runtimes', 'runtime.profile_config_unsupported', { unsupported });
     }
 }
 export class V1RuntimesClient {
     http;
+    files;
+    runs;
+    invocations;
+    targets;
     constructor(http) {
         this.http = http;
+        this.files = new V1RuntimeFilesNamespaceClient(http);
+        this.runs = new V1RuntimeRunsNamespaceClient(http);
+        this.invocations = new V1RuntimeInvocationsNamespaceClient(http);
+        this.targets = new V1RuntimeTargetsNamespaceClient(http);
     }
     list(query = {}) {
         return this.http.request('/runtimes', { query });
@@ -126,31 +118,93 @@ export class V1RuntimesClient {
     }
     async create(request) {
         validateRuntimeCreateRequest(request);
-        const runtime = await this.http.request('/runtimes', {
+        return this.http.request('/runtimes', {
             method: 'POST',
             body: request,
         });
-        return new V1RuntimeResource(this.http, runtime);
     }
     async createInSpace(spaceId, request) {
         validateRuntimeCreateRequest(request);
-        const runtime = await this.http.request('/runtimes', {
+        return this.http.request('/runtimes', {
             method: 'POST',
             body: { ...request, spaceId },
         });
-        return new V1RuntimeResource(this.http, runtime);
     }
-    async get(id) {
-        const runtime = await this.http.request(`/runtimes/${encodeURIComponent(id)}`);
-        return new V1RuntimeResource(this.http, runtime);
+    update(id, request) {
+        return this.http.request(`/runtimes/${encodeURIComponent(id)}`, {
+            method: 'PATCH',
+            body: request,
+        });
+    }
+    delete(id, options = {}) {
+        return this.http.request(`/runtimes/${encodeURIComponent(id)}${options.force ? '?force=true' : ''}`, { method: 'DELETE' });
+    }
+    get(id) {
+        return this.http.request(`/runtimes/${encodeURIComponent(id)}`);
     }
     stop(id) {
         return this.http.request(`/runtimes/${encodeURIComponent(id)}/stop`, {
             method: 'POST',
         });
     }
-    async start(id) {
-        const runtime = await this.get(id);
-        return runtime.start();
+    async start(id, options) {
+        return this.http.request(`/runtimes/${encodeURIComponent(id)}/start`, {
+            method: 'POST',
+            headers: v1IdempotencyHeaders(options),
+        });
+    }
+}
+export class V1RuntimeRunsNamespaceClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(runtimeId, query = {}) {
+        return new V1RuntimeRunsClient(this.http, runtimeId).list(query);
+    }
+    iter(runtimeId, query = {}) {
+        return new V1RuntimeRunsClient(this.http, runtimeId).iter(query);
+    }
+}
+export class V1RuntimeFilesNamespaceClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(runtimeId, query = {}) {
+        return new V1RuntimeFilesClient(this.http, runtimeId).list(query);
+    }
+    iter(runtimeId, query = {}) {
+        return new V1RuntimeFilesClient(this.http, runtimeId).iter(query);
+    }
+    upload(runtimeId, request) {
+        return new V1RuntimeFilesClient(this.http, runtimeId).upload(request);
+    }
+    stage(runtimeId, request) {
+        return new V1RuntimeFilesClient(this.http, runtimeId).stage(request);
+    }
+    collect(runtimeId, request) {
+        return new V1RuntimeFilesClient(this.http, runtimeId).collect(request);
+    }
+}
+export class V1RuntimeTargetsNamespaceClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(runtimeId) {
+        return new V1RuntimeTargetsClient(this.http, runtimeId).list();
+    }
+    create(runtimeId, request = {}) {
+        return new V1RuntimeTargetsClient(this.http, runtimeId).create(request);
+    }
+    get(runtimeId, targetId) {
+        return new V1RuntimeTargetsClient(this.http, runtimeId).get(targetId);
+    }
+    activate(runtimeId, targetId) {
+        return new V1RuntimeTargetsClient(this.http, runtimeId).activate(targetId);
+    }
+    delete(runtimeId, targetId) {
+        return new V1RuntimeTargetsClient(this.http, runtimeId).delete(targetId);
     }
 }

package/dist/schemas.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import type { JsonObject } from './types.js';
+export type JsonSchemaObject = JsonObject;
+export type JsonSchemaLike = JsonSchemaObject | {
+    toJSONSchema: () => unknown;
+} | z.ZodType;
+export declare function toOutputSchema(schema: JsonSchemaLike, label?: string): JsonSchemaObject;

package/dist/schemas.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export function toOutputSchema(schema, label = 'schema') {
+    const value = resolveSchema(schema);
+    if (!isJsonObject(value)) {
+        throw new TypeError(`${label} must resolve to a JSON Schema object`);
+    }
+    const { $schema, ...jsonSchema } = value;
+    void $schema;
+    return jsonSchema;
+}
+function resolveSchema(schema) {
+    if (hasToJSONSchema(schema)) {
+        return schema.toJSONSchema();
+    }
+    const zodJsonSchema = tryZodToJsonSchema(schema);
+    if (zodJsonSchema !== undefined)
+        return zodJsonSchema;
+    return schema;
+}
+function hasToJSONSchema(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        'toJSONSchema' in value &&
+        typeof value.toJSONSchema === 'function');
+}
+function tryZodToJsonSchema(value) {
+    try {
+        return z.toJSONSchema(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isJsonObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/spaces.d.ts

@@ -1,40 +1,28 @@
 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: V1HttpClient, spaceId: string);
-    get(): Promise<V1SpaceEnvironment>;
-    update(request: V1SpaceEnvironmentUpdateRequest): Promise<V1SpaceEnvironment>;
-}
-export declare class V1SpaceRuntimesClient {
+import { V1RuntimesClient } from './runtimes.js';
+import type { V1ListEnvelope, V1Runtime, V1RuntimeListQuery, V1Space, V1SpaceCreateRequest, V1SpaceDeleteResponse, V1SpaceEnvironment, V1SpaceEnvironmentUpdateRequest, V1SpaceListQuery, V1SpaceRuntimeCreateRequest, V1SpaceUpdateRequest } from './types.js';
+export declare class V1SpacesClient {
     private readonly http;
-    private readonly spaceId;
-    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']>;
+    readonly environment: V1SpaceEnvironmentNamespaceClient;
+    readonly runtimes: V1SpaceRuntimesNamespaceClient;
+    constructor(http: V1HttpClient);
+    list(query?: V1SpaceListQuery): Promise<V1ListEnvelope<V1Space>>;
+    iter(query?: V1SpaceListQuery): AsyncGenerator<V1Space, void, undefined>;
+    create(request: V1SpaceCreateRequest): Promise<V1Space>;
+    get(id: string): Promise<V1Space>;
+    update(id: string, request: V1SpaceUpdateRequest): Promise<V1Space>;
+    delete(id: string): Promise<V1SpaceDeleteResponse>;
 }
-export declare class V1SpaceResource {
+export declare class V1SpaceEnvironmentNamespaceClient {
     private readonly http;
-    readonly data: V1Space;
-    readonly environment: V1SpaceEnvironmentClient;
-    readonly runtimes: V1SpaceRuntimesClient;
-    constructor(http: V1HttpClient, data: V1Space);
-    get id(): string;
-    refresh(): Promise<V1SpaceResource>;
-    update(request: V1SpaceUpdateRequest): Promise<V1SpaceResource>;
+    constructor(http: V1HttpClient);
+    get(spaceId: string): Promise<V1SpaceEnvironment>;
+    update(spaceId: string, request: V1SpaceEnvironmentUpdateRequest): Promise<V1SpaceEnvironment>;
 }
-export declare class V1SpacesClient {
+export declare class V1SpaceRuntimesNamespaceClient {
     private readonly http;
     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>;
+    list(spaceId: string, query?: Omit<V1RuntimeListQuery, 'spaceId'>): ReturnType<V1RuntimesClient['list']>;
+    iter(spaceId: string, query?: Omit<V1RuntimeListQuery, 'spaceId'>): ReturnType<V1RuntimesClient['iter']>;
+    create(spaceId: string, request: V1SpaceRuntimeCreateRequest): Promise<V1Runtime>;
 }

package/dist/spaces.js

@@ -1,6 +1,6 @@
 import { iterateV1Pages } from './pagination.js';
 import { V1RuntimesClient } from './runtimes.js';
-export class V1SpaceEnvironmentClient {
+class V1SpaceEnvironmentClient {
     http;
     spaceId;
     constructor(http, spaceId) {
@@ -17,7 +17,7 @@ export class V1SpaceEnvironmentClient {
         });
     }
 }
-export class V1SpaceRuntimesClient {
+class V1SpaceRuntimesClient {
     http;
     spaceId;
     constructor(http, spaceId) {
@@ -30,10 +30,10 @@ export class V1SpaceRuntimesClient {
     iter(query = {}) {
         return new V1RuntimesClient(this.http).iter({ ...query, spaceId: this.spaceId });
     }
-    async create(request) {
+    create(request) {
         return new V1RuntimesClient(this.http).createInSpace(this.spaceId, request);
     }
-    async get(runtimeId) {
+    get(runtimeId) {
         return new V1RuntimesClient(this.http).get(runtimeId);
     }
     stop(runtimeId) {
@@ -43,54 +43,66 @@ export class V1SpaceRuntimesClient {
         return new V1RuntimesClient(this.http).start(runtimeId);
     }
 }
-export class V1SpaceResource {
+export class V1SpacesClient {
     http;
-    data;
     environment;
     runtimes;
-    constructor(http, data) {
+    constructor(http) {
         this.http = http;
-        this.data = data;
-        this.environment = new V1SpaceEnvironmentClient(http, data.id);
-        this.runtimes = new V1SpaceRuntimesClient(http, data.id);
+        this.environment = new V1SpaceEnvironmentNamespaceClient(http);
+        this.runtimes = new V1SpaceRuntimesNamespaceClient(http);
     }
-    get id() {
-        return this.data.id;
+    list(query = {}) {
+        return this.http.request('/spaces', { query });
     }
-    refresh() {
-        return new V1SpacesClient(this.http).get(this.id);
+    iter(query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
+    }
+    create(request) {
+        return this.http.request('/spaces', {
+            method: 'POST',
+            body: request,
+        });
+    }
+    get(id) {
+        return this.http.request(`/spaces/${encodeURIComponent(id)}`);
+    }
+    update(id, request) {
+        return this.http.request(`/spaces/${encodeURIComponent(id)}`, {
+            method: 'PATCH',
+            body: request,
+        });
     }
-    async update(request) {
-        return new V1SpacesClient(this.http).update(this.id, request);
+    delete(id) {
+        return this.http.request(`/spaces/${encodeURIComponent(id)}`, {
+            method: 'DELETE',
+        });
     }
 }
-export class V1SpacesClient {
+export class V1SpaceEnvironmentNamespaceClient {
     http;
     constructor(http) {
         this.http = http;
     }
-    async list() {
-        return this.http.request('/spaces');
+    get(spaceId) {
+        return new V1SpaceEnvironmentClient(this.http, spaceId).get();
     }
-    iter() {
-        return iterateV1Pages({}, () => this.list());
+    update(spaceId, request) {
+        return new V1SpaceEnvironmentClient(this.http, spaceId).update(request);
     }
-    async create(request) {
-        const space = await this.http.request('/spaces', {
-            method: 'POST',
-            body: request,
-        });
-        return new V1SpaceResource(this.http, space);
+}
+export class V1SpaceRuntimesNamespaceClient {
+    http;
+    constructor(http) {
+        this.http = http;
     }
-    async get(id) {
-        const space = await this.http.request(`/spaces/${encodeURIComponent(id)}`);
-        return new V1SpaceResource(this.http, space);
+    list(spaceId, query = {}) {
+        return new V1RuntimesClient(this.http).list({ ...query, spaceId });
     }
-    async update(id, request) {
-        const space = await this.http.request(`/spaces/${encodeURIComponent(id)}`, {
-            method: 'PATCH',
-            body: request,
-        });
-        return new V1SpaceResource(this.http, space);
+    iter(spaceId, query = {}) {
+        return new V1RuntimesClient(this.http).iter({ ...query, spaceId });
+    }
+    create(spaceId, request) {
+        return new V1RuntimesClient(this.http).createInSpace(spaceId, request);
     }
 }

package/dist/toolCallTypes.d.ts

@@ -0,0 +1,41 @@
+import type { JsonObject, JsonValue, V1PageQuery, V1ToolType } from './types.js';
+export type V1ToolCallActor = 'test' | 'agent' | 'invocation';
+export type V1ToolCallStatus = 'succeeded' | 'failed';
+export interface V1ToolCallTool {
+    id: string;
+    name: string;
+    type: V1ToolType;
+}
+export interface V1ToolCall {
+    id: string;
+    toolCallId: string;
+    spaceId: string;
+    runId?: string | null;
+    invocationId?: string | null;
+    toolsetId?: string | null;
+    tool: V1ToolCallTool;
+    actor: V1ToolCallActor;
+    status: V1ToolCallStatus;
+    redactedInput?: JsonValue;
+    redactedOutput?: JsonValue;
+    redactedError?: JsonObject | null;
+    inputSummary?: JsonObject | null;
+    outputSummary?: JsonObject | null;
+    error?: {
+        code: string;
+        message: string;
+        details?: JsonObject;
+    } | null;
+    startedAt: string;
+    finishedAt: string;
+    durationMs: number;
+    createdAt: string;
+}
+export interface V1ToolCallListQuery extends V1PageQuery {
+    spaceId?: string;
+    runId?: string;
+    invocationId?: string;
+    toolId?: string;
+    status?: V1ToolCallStatus;
+    actor?: V1ToolCallActor;
+}

package/dist/toolCallTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/toolCalls.d.ts

@@ -0,0 +1,9 @@
+import type { V1HttpClient } from './http.js';
+import type { V1ListEnvelope, V1ToolCall, V1ToolCallListQuery } from './types.js';
+export declare class V1ToolCallsClient {
+    private readonly http;
+    constructor(http: V1HttpClient);
+    list(query?: V1ToolCallListQuery): Promise<V1ListEnvelope<V1ToolCall>>;
+    iter(query?: V1ToolCallListQuery): AsyncGenerator<V1ToolCall, void, undefined>;
+    get(toolCallId: string): Promise<V1ToolCall>;
+}

package/dist/toolCalls.js

@@ -0,0 +1,16 @@
+import { iterateV1Pages } from './pagination.js';
+export class V1ToolCallsClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(query = {}) {
+        return this.http.request('/tool-calls', { query });
+    }
+    iter(query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
+    }
+    get(toolCallId) {
+        return this.http.request(`/tool-calls/${encodeURIComponent(toolCallId)}`);
+    }
+}

package/dist/tools.d.ts

@@ -0,0 +1,23 @@
+import type { V1HttpClient } from './http.js';
+import type { JsonObject, V1ListEnvelope, V1PageQuery, V1Tool, V1ToolCreateRequest, V1ToolUpdateRequest, V1ToolVersion, V1ToolVersionCreateRequest } from './types.js';
+export interface V1ToolListQuery extends V1PageQuery {
+    spaceId?: string;
+}
+export type V1ToolVersionListQuery = V1PageQuery;
+export declare class V1ToolsClient {
+    private readonly http;
+    constructor(http: V1HttpClient);
+    list(query?: V1ToolListQuery): Promise<V1ListEnvelope<V1Tool>>;
+    iter(query?: V1ToolListQuery): AsyncGenerator<V1Tool, void, undefined>;
+    create(request: V1ToolCreateRequest): Promise<V1Tool>;
+    get(id: string): Promise<V1Tool>;
+    update(id: string, request: V1ToolUpdateRequest): Promise<V1Tool>;
+    test(id: string, request?: {
+        input?: unknown;
+    }): Promise<unknown>;
+    listVersions(id: string, query?: V1ToolVersionListQuery): Promise<V1ListEnvelope<V1ToolVersion>>;
+    createVersion(id: string, request: V1ToolVersionCreateRequest): Promise<V1ToolVersion>;
+    getVersion(id: string, versionId: string): Promise<V1ToolVersion>;
+    promoteVersion(id: string, versionId: string): Promise<V1ToolVersion>;
+}
+export declare function passthroughJsonSchema(): JsonObject;

package/dist/tools.js

@@ -0,0 +1,49 @@
+import { iterateV1Pages } from './pagination.js';
+export class V1ToolsClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(query = {}) {
+        return this.http.request('/tools', { query });
+    }
+    iter(query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
+    }
+    create(request) {
+        return this.http.request('/tools', { method: 'POST', body: request });
+    }
+    get(id) {
+        return this.http.request(`/tools/${encodeURIComponent(id)}`);
+    }
+    update(id, request) {
+        return this.http.request(`/tools/${encodeURIComponent(id)}`, {
+            method: 'PATCH',
+            body: request,
+        });
+    }
+    test(id, request = {}) {
+        return this.http.request(`/tools/${encodeURIComponent(id)}/test`, {
+            method: 'POST',
+            body: request,
+        });
+    }
+    listVersions(id, query = {}) {
+        return this.http.request(`/tools/${encodeURIComponent(id)}/versions`, { query });
+    }
+    createVersion(id, request) {
+        return this.http.request(`/tools/${encodeURIComponent(id)}/versions`, {
+            method: 'POST',
+            body: request,
+        });
+    }
+    getVersion(id, versionId) {
+        return this.http.request(`/tools/${encodeURIComponent(id)}/versions/${encodeURIComponent(versionId)}`);
+    }
+    promoteVersion(id, versionId) {
+        return this.http.request(`/tools/${encodeURIComponent(id)}/versions/${encodeURIComponent(versionId)}/promote`, { method: 'POST' });
+    }
+}
+export function passthroughJsonSchema() {
+    return { type: 'object', additionalProperties: true };
+}

package/dist/toolsetTypes.d.ts

@@ -0,0 +1,32 @@
+import type { JsonObject, V1PageQuery } from './types.js';
+export type V1ToolsetBuiltinName = 'files' | 'vault' | 'captcha';
+export interface V1Toolset {
+    id: string;
+    spaceId: string;
+    name: string;
+    builtins: V1ToolsetBuiltinName[];
+    toolIds: string[];
+    metadata?: JsonObject | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface V1ToolsetListQuery extends V1PageQuery {
+    spaceId?: string;
+}
+export interface V1ToolsetCreateRequest {
+    spaceId?: string;
+    name: string;
+    builtins?: V1ToolsetBuiltinName[];
+    toolIds?: string[];
+    metadata?: JsonObject | null;
+}
+export interface V1ToolsetUpdateRequest {
+    name?: string;
+    builtins?: V1ToolsetBuiltinName[];
+    toolIds?: string[];
+    metadata?: JsonObject | null;
+}
+export interface V1ToolsetDeleteResponse {
+    id: string;
+    deleted: true;
+}

package/dist/toolsetTypes.js

@@ -0,0 +1 @@
+export {};