@bctrl/sdk 1.0.9 → 1.0.11

package/dist/runs.js

@@ -1,75 +1,22 @@
-import { v1IdempotencyHeaders } from './http.js';
 import { iterateV1Pages } from './pagination.js';
-class V1RunEventsClient {
-    http;
-    runId;
-    constructor(http, runId) {
-        this.http = http;
-        this.runId = runId;
-    }
-    list(query = {}) {
-        return this.http.request(`/runs/${encodeURIComponent(this.runId)}/events`, { query });
-    }
-    iter(query = {}) {
-        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
-    }
-    streamUrl(query = {}) {
-        const url = new URL(`${this.http.baseUrl}/runs/${encodeURIComponent(this.runId)}/events/stream`);
-        for (const [key, value] of Object.entries(query)) {
-            if (value === undefined)
-                continue;
-            if (Array.isArray(value)) {
-                for (const item of value)
-                    url.searchParams.append(key, item);
-            }
-            else {
-                url.searchParams.set(key, value);
-            }
-        }
-        return url.toString();
-    }
-}
-class V1RunActivityClient {
-    http;
-    runId;
-    constructor(http, runId) {
-        this.http = http;
-        this.runId = runId;
-    }
-    list(query = {}) {
-        return this.http.request(`/runs/${encodeURIComponent(this.runId)}/activity`, { query });
-    }
-    iter(query = {}) {
-        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
-    }
-    streamUrl(query = {}) {
-        const url = new URL(`${this.http.baseUrl}/runs/${encodeURIComponent(this.runId)}/activity/stream`);
-        for (const [key, value] of Object.entries(query)) {
-            if (value === undefined)
-                continue;
-            if (Array.isArray(value)) {
-                for (const item of value)
-                    url.searchParams.append(key, String(item));
-            }
-            else {
-                url.searchParams.set(key, String(value));
-            }
-        }
-        return url.toString();
+function streamUrl(http, runId, query) {
+    const url = new URL(`${http.baseUrl}/runs/${encodeURIComponent(runId)}/stream`);
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined)
+            url.searchParams.set(key, String(value));
     }
+    return url.toString();
 }
 export class V1RunsClient {
     http;
     events;
-    activity;
+    trace;
     files;
-    invocations;
     constructor(http) {
         this.http = http;
         this.events = new V1RunEventsNamespaceClient(http);
-        this.activity = new V1RunActivityNamespaceClient(http);
+        this.trace = new V1RunTraceNamespaceClient(http);
         this.files = new V1RunFilesNamespaceClient(http);
-        this.invocations = new V1RunInvocationsNamespaceClient(http);
     }
     list(query = {}) {
         return this.http.request('/runs', { query });
@@ -77,23 +24,14 @@ export class V1RunsClient {
     iter(query = {}) {
         return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
-    get(id) {
-        return this.http.request(`/runs/${encodeURIComponent(id)}`);
-    }
-    usage(id) {
-        return this.http.request(`/runs/${encodeURIComponent(id)}/usage`);
+    get(runId, query = {}) {
+        return this.http.request(`/runs/${encodeURIComponent(runId)}`, { query });
     }
-    live(id, request) {
-        return this.http.request(`/runs/${encodeURIComponent(id)}/live`, {
-            method: 'POST',
-            body: request ?? {},
-        });
+    streamUrl(runId, query = {}) {
+        return streamUrl(this.http, runId, query);
     }
-    recording(id, request) {
-        return this.http.request(`/runs/${encodeURIComponent(id)}/recording`, {
-            method: 'POST',
-            body: request ?? {},
-        });
+    stream(runId, query = {}, options = {}) {
+        return this.http.streamSse(`/runs/${encodeURIComponent(runId)}/stream`, { query, signal: options.signal });
     }
 }
 export class V1RunEventsNamespaceClient {
@@ -102,61 +40,30 @@ export class V1RunEventsNamespaceClient {
         this.http = http;
     }
     list(runId, query = {}) {
-        return new V1RunEventsClient(this.http, runId).list(query);
-    }
-    iter(runId, query = {}) {
-        return new V1RunEventsClient(this.http, runId).iter(query);
-    }
-    streamUrl(runId, query = {}) {
-        return new V1RunEventsClient(this.http, runId).streamUrl(query);
-    }
-}
-export class V1RunActivityNamespaceClient {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    list(runId, query = {}) {
-        return new V1RunActivityClient(this.http, runId).list(query);
+        return this.http.request(`/runs/${encodeURIComponent(runId)}/events`, { query });
     }
     iter(runId, query = {}) {
-        return new V1RunActivityClient(this.http, runId).iter(query);
-    }
-    streamUrl(runId, query = {}) {
-        return new V1RunActivityClient(this.http, runId).streamUrl(query);
+        return iterateV1Pages(query, (pageQuery) => this.list(runId, pageQuery));
     }
 }
-export class V1RunFilesNamespaceClient {
+export class V1RunTraceNamespaceClient {
     http;
     constructor(http) {
         this.http = http;
     }
     list(runId, query = {}) {
-        return this.http.request(`/runs/${encodeURIComponent(runId)}/files`, { query });
+        return this.http.request(`/runs/${encodeURIComponent(runId)}/trace`, { query });
     }
     iter(runId, query = {}) {
         return iterateV1Pages(query, (pageQuery) => this.list(runId, pageQuery));
     }
-    export(runId, request = {}, options) {
-        return this.http.request(`/runs/${encodeURIComponent(runId)}/files/export`, {
-            method: 'POST',
-            body: request,
-            headers: v1IdempotencyHeaders(options),
-        });
-    }
 }
-export class V1RunInvocationsNamespaceClient {
+export class V1RunFilesNamespaceClient {
     http;
     constructor(http) {
         this.http = http;
     }
-    list(runId, query = {}) {
-        return this.http.request(`/runs/${encodeURIComponent(runId)}/invocations`, { query });
-    }
-    iter(runId, query = {}) {
-        return iterateV1Pages(query, (pageQuery) => this.list(runId, pageQuery));
-    }
-    get(runId, invocationId) {
-        return this.http.request(`/runs/${encodeURIComponent(runId)}/invocations/${encodeURIComponent(invocationId)}`);
+    list(runId) {
+        return this.http.request(`/runs/${encodeURIComponent(runId)}/files`);
     }
 }

package/dist/runtimes.d.ts

@@ -1,61 +1,19 @@
 import { type V1HttpClient, type V1IdempotencyOptions } from './http.js';
-import { V1RuntimeInvocationsNamespaceClient } from './invocations.js';
-import type { V1ListEnvelope, V1File, V1HumanAction, V1HumanActionCreateRequest, V1HumanActionWaitRequest, V1HumanActionWaitResponse, V1Runtime, V1RuntimeCreateRequest, V1RuntimeDeleteResponse, V1RuntimeFileCollectRequest, V1RuntimeFilesListQuery, V1RuntimeFileStageRequest, V1RuntimeFileUploadRequest, V1RuntimeStagedFile, V1RuntimeListQuery, V1RuntimeRunListQuery, V1RuntimeStartResponse, V1RuntimeStopResponse, V1RuntimeTarget, V1RuntimeTargetCreateRequest, V1RuntimeUpdateRequest, V1RunSummary, V1SpaceRuntimeCreateRequest } from './types.js';
+import type { V1ListEnvelope, V1Runtime, V1RuntimeCreateRequest, V1RuntimeCreateResponse, V1RuntimeDeleteResponse, V1RuntimeGetQuery, V1RuntimeListQuery, V1RuntimeStartResponse, V1RuntimeStopResponse, V1RuntimeSummary, V1RuntimeUpdateRequest } from './types.js';
 export type V1RuntimeStartResult = V1RuntimeStartResponse;
 export declare class V1RuntimesClient {
     private readonly http;
-    readonly files: V1RuntimeFilesNamespaceClient;
-    readonly runs: V1RuntimeRunsNamespaceClient;
-    readonly invocations: V1RuntimeInvocationsNamespaceClient;
-    readonly targets: V1RuntimeTargetsNamespaceClient;
-    readonly humanAction: V1RuntimeHumanActionsNamespaceClient;
-    readonly humanActions: V1RuntimeHumanActionsNamespaceClient;
     constructor(http: V1HttpClient);
-    list(query?: V1RuntimeListQuery): Promise<V1ListEnvelope<V1Runtime>>;
-    iter(query?: V1RuntimeListQuery): AsyncGenerator<V1Runtime, void, undefined>;
-    create(request: V1RuntimeCreateRequest): Promise<V1Runtime>;
-    createInSpace(spaceId: string, request: V1SpaceRuntimeCreateRequest): Promise<V1Runtime>;
-    update(id: string, request: V1RuntimeUpdateRequest): Promise<V1Runtime>;
-    delete(id: string, options?: {
+    list(query?: V1RuntimeListQuery): Promise<V1ListEnvelope<V1RuntimeSummary>>;
+    iter(query?: V1RuntimeListQuery): AsyncGenerator<V1RuntimeSummary, void, undefined>;
+    create(request: V1RuntimeCreateRequest, options?: V1IdempotencyOptions): Promise<V1RuntimeCreateResponse>;
+    get(runtimeId: string, query?: V1RuntimeGetQuery): Promise<V1Runtime>;
+    update(runtimeId: string, request: V1RuntimeUpdateRequest): Promise<V1Runtime>;
+    delete(runtimeId: string, options?: {
         force?: boolean;
     }): Promise<V1RuntimeDeleteResponse>;
-    get(id: string): Promise<V1Runtime>;
-    stop(id: string): Promise<V1RuntimeStopResponse>;
-    start(id: string, options?: V1IdempotencyOptions): Promise<V1RuntimeStartResult>;
-}
-export declare class V1RuntimeRunsNamespaceClient {
-    private readonly http;
-    constructor(http: V1HttpClient);
-    list(runtimeId: string, query?: V1RuntimeRunListQuery): Promise<V1ListEnvelope<V1RunSummary>>;
-    iter(runtimeId: string, query?: V1RuntimeRunListQuery): AsyncGenerator<V1RunSummary, void, undefined>;
-}
-export declare class V1RuntimeFilesNamespaceClient {
-    private readonly http;
-    constructor(http: V1HttpClient);
-    list(runtimeId: string, query?: V1RuntimeFilesListQuery): Promise<V1ListEnvelope<V1File>>;
-    iter(runtimeId: string, query?: V1RuntimeFilesListQuery): AsyncGenerator<V1File, void, undefined>;
-    upload(runtimeId: string, request: V1RuntimeFileUploadRequest): Promise<V1RuntimeStagedFile>;
-    stage(runtimeId: string, request: V1RuntimeFileStageRequest): Promise<V1RuntimeStagedFile>;
-    collect(runtimeId: string, request: V1RuntimeFileCollectRequest): Promise<V1File>;
-}
-export declare class V1RuntimeHumanActionsNamespaceClient {
-    private readonly http;
-    constructor(http: V1HttpClient);
-    create(runtimeId: string, request: V1HumanActionCreateRequest): Promise<V1HumanAction>;
-    get(runtimeId: string): Promise<V1HumanAction>;
-    complete(runtimeId: string): Promise<V1HumanAction>;
-    cancel(runtimeId: string): Promise<V1HumanAction>;
-    wait(runtimeId: string, request?: V1HumanActionWaitRequest): Promise<V1HumanActionWaitResponse>;
-}
-export declare class V1RuntimeTargetsNamespaceClient {
-    private readonly http;
-    constructor(http: V1HttpClient);
-    list(runtimeId: string): Promise<V1ListEnvelope<V1RuntimeTarget>>;
-    create(runtimeId: string, request?: V1RuntimeTargetCreateRequest): Promise<V1RuntimeTarget>;
-    get(runtimeId: string, targetId: string): Promise<V1RuntimeTarget>;
-    activate(runtimeId: string, targetId: string): Promise<V1RuntimeTarget>;
-    delete(runtimeId: string, targetId: string): Promise<{
-        id: string;
-        deleted: boolean;
-    }>;
+    start(runtimeId: string, options?: V1IdempotencyOptions & {
+        recording?: boolean;
+    }): Promise<V1RuntimeStartResponse>;
+    stop(runtimeId: string): Promise<V1RuntimeStopResponse>;
 }

package/dist/runtimes.js

@@ -1,137 +1,9 @@
 import { v1IdempotencyHeaders } from './http.js';
-import { V1RuntimeInvocationsNamespaceClient } from './invocations.js';
 import { iterateV1Pages } from './pagination.js';
-class V1RuntimeRunsClient {
-    http;
-    runtimeId;
-    constructor(http, runtimeId) {
-        this.http = http;
-        this.runtimeId = runtimeId;
-    }
-    list(query = {}) {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/runs`, { query });
-    }
-    iter(query = {}) {
-        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
-    }
-}
-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) {
-            form.set('file', request.file, request.name);
-            form.set('name', request.name);
-        }
-        else {
-            form.set('file', request.file);
-        }
-        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`, {
-            method: 'POST',
-            body: form,
-        });
-    }
-    stage(request) {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/files/stage`, {
-            method: 'POST',
-            body: request,
-        });
-    }
-    collect(request) {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/files/collect`, {
-            method: 'POST',
-            body: request,
-        });
-    }
-}
-class V1RuntimeTargetsClient {
-    http;
-    runtimeId;
-    constructor(http, runtimeId) {
-        this.http = http;
-        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,
-        });
-    }
-    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' });
-    }
-}
-class V1RuntimeHumanActionsClient {
-    http;
-    runtimeId;
-    constructor(http, runtimeId) {
-        this.http = http;
-        this.runtimeId = runtimeId;
-    }
-    create(request) {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/human-actions`, {
-            method: 'POST',
-            body: request,
-        });
-    }
-    get() {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/human-actions`);
-    }
-    complete() {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/human-actions/complete`, { method: 'POST' });
-    }
-    cancel() {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/human-actions/cancel`, { method: 'POST' });
-    }
-    wait(request = {}) {
-        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/human-actions/wait`, {
-            method: 'POST',
-            body: request,
-        });
-    }
-}
 export class V1RuntimesClient {
     http;
-    files;
-    runs;
-    invocations;
-    targets;
-    humanAction;
-    humanActions;
     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);
-        this.humanAction = new V1RuntimeHumanActionsNamespaceClient(http);
-        this.humanActions = this.humanAction;
     }
     list(query = {}) {
         return this.http.request('/runtimes', { query });
@@ -139,114 +11,39 @@ export class V1RuntimesClient {
     iter(query = {}) {
         return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
-    async create(request) {
+    create(request, options) {
         return this.http.request('/runtimes', {
             method: 'POST',
             body: request,
+            headers: v1IdempotencyHeaders(options),
         });
     }
-    async createInSpace(spaceId, request) {
-        return this.http.request('/runtimes', {
-            method: 'POST',
-            body: { ...request, spaceId },
-        });
+    get(runtimeId, query = {}) {
+        return this.http.request(`/runtimes/${encodeURIComponent(runtimeId)}`, { query });
     }
-    update(id, request) {
-        return this.http.request(`/runtimes/${encodeURIComponent(id)}`, {
+    update(runtimeId, request) {
+        return this.http.request(`/runtimes/${encodeURIComponent(runtimeId)}`, {
             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)}`);
+    delete(runtimeId, options = {}) {
+        return this.http.request(`/runtimes/${encodeURIComponent(runtimeId)}`, {
+            method: 'DELETE',
+            query: options,
+        });
     }
-    stop(id) {
-        return this.http.request(`/runtimes/${encodeURIComponent(id)}/stop`, {
+    start(runtimeId, options = {}) {
+        const { recording, ...idempotency } = options;
+        return this.http.request(`/runtimes/${encodeURIComponent(runtimeId)}/start`, {
             method: 'POST',
+            ...(recording === undefined ? {} : { body: { recording } }),
+            headers: v1IdempotencyHeaders(idempotency),
         });
     }
-    async start(id, options) {
-        return this.http.request(`/runtimes/${encodeURIComponent(id)}/start`, {
+    stop(runtimeId) {
+        return this.http.request(`/runtimes/${encodeURIComponent(runtimeId)}/stop`, {
             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 V1RuntimeHumanActionsNamespaceClient {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    create(runtimeId, request) {
-        return new V1RuntimeHumanActionsClient(this.http, runtimeId).create(request);
-    }
-    get(runtimeId) {
-        return new V1RuntimeHumanActionsClient(this.http, runtimeId).get();
-    }
-    complete(runtimeId) {
-        return new V1RuntimeHumanActionsClient(this.http, runtimeId).complete();
-    }
-    cancel(runtimeId) {
-        return new V1RuntimeHumanActionsClient(this.http, runtimeId).cancel();
-    }
-    wait(runtimeId, request = {}) {
-        return new V1RuntimeHumanActionsClient(this.http, runtimeId).wait(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/spaces.d.ts

@@ -1,10 +1,7 @@
 import type { V1HttpClient } from './http.js';
-import { V1RuntimesClient } from './runtimes.js';
-import type { V1ListEnvelope, V1Runtime, V1RuntimeListQuery, V1Space, V1SpaceCreateRequest, V1SpaceDeleteResponse, V1SpaceEnvironment, V1SpaceEnvironmentUpdateRequest, V1SpaceListQuery, V1SpaceRuntimeCreateRequest, V1SpaceUpdateRequest } from './types.js';
+import type { V1ListEnvelope, V1Space, V1SpaceCreateRequest, V1SpaceDeleteResponse, V1SpaceListQuery, V1SpaceUpdateRequest } from './types.js';
 export declare class V1SpacesClient {
     private readonly http;
-    readonly environment: V1SpaceEnvironmentNamespaceClient;
-    readonly runtimes: V1SpaceRuntimesNamespaceClient;
     constructor(http: V1HttpClient);
     list(query?: V1SpaceListQuery): Promise<V1ListEnvelope<V1Space>>;
     iter(query?: V1SpaceListQuery): AsyncGenerator<V1Space, void, undefined>;
@@ -13,16 +10,3 @@ export declare class V1SpacesClient {
     update(id: string, request: V1SpaceUpdateRequest): Promise<V1Space>;
     delete(id: string): Promise<V1SpaceDeleteResponse>;
 }
-export declare class V1SpaceEnvironmentNamespaceClient {
-    private readonly http;
-    constructor(http: V1HttpClient);
-    get(spaceId: string): Promise<V1SpaceEnvironment>;
-    update(spaceId: string, request: V1SpaceEnvironmentUpdateRequest): Promise<V1SpaceEnvironment>;
-}
-export declare class V1SpaceRuntimesNamespaceClient {
-    private readonly http;
-    constructor(http: V1HttpClient);
-    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,56 +1,8 @@
 import { iterateV1Pages } from './pagination.js';
-import { V1RuntimesClient } from './runtimes.js';
-class V1SpaceEnvironmentClient {
-    http;
-    spaceId;
-    constructor(http, spaceId) {
-        this.http = http;
-        this.spaceId = spaceId;
-    }
-    get() {
-        return this.http.request(`/spaces/${encodeURIComponent(this.spaceId)}/environment`);
-    }
-    update(request) {
-        return this.http.request(`/spaces/${encodeURIComponent(this.spaceId)}/environment`, {
-            method: 'PATCH',
-            body: request,
-        });
-    }
-}
-class V1SpaceRuntimesClient {
-    http;
-    spaceId;
-    constructor(http, spaceId) {
-        this.http = http;
-        this.spaceId = spaceId;
-    }
-    list(query = {}) {
-        return new V1RuntimesClient(this.http).list({ ...query, spaceId: this.spaceId });
-    }
-    iter(query = {}) {
-        return new V1RuntimesClient(this.http).iter({ ...query, spaceId: this.spaceId });
-    }
-    create(request) {
-        return new V1RuntimesClient(this.http).createInSpace(this.spaceId, request);
-    }
-    get(runtimeId) {
-        return new V1RuntimesClient(this.http).get(runtimeId);
-    }
-    stop(runtimeId) {
-        return new V1RuntimesClient(this.http).stop(runtimeId);
-    }
-    start(runtimeId) {
-        return new V1RuntimesClient(this.http).start(runtimeId);
-    }
-}
 export class V1SpacesClient {
     http;
-    environment;
-    runtimes;
     constructor(http) {
         this.http = http;
-        this.environment = new V1SpaceEnvironmentNamespaceClient(http);
-        this.runtimes = new V1SpaceRuntimesNamespaceClient(http);
     }
     list(query = {}) {
         return this.http.request('/spaces', { query });
@@ -79,30 +31,3 @@ export class V1SpacesClient {
         });
     }
 }
-export class V1SpaceEnvironmentNamespaceClient {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    get(spaceId) {
-        return new V1SpaceEnvironmentClient(this.http, spaceId).get();
-    }
-    update(spaceId, request) {
-        return new V1SpaceEnvironmentClient(this.http, spaceId).update(request);
-    }
-}
-export class V1SpaceRuntimesNamespaceClient {
-    http;
-    constructor(http) {
-        this.http = http;
-    }
-    list(spaceId, query = {}) {
-        return new V1RuntimesClient(this.http).list({ ...query, spaceId });
-    }
-    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

@@ -1,6 +1,6 @@
 import type { OpenApiQuery, OpenApiSchemas } from './openapi.js';
-export type V1ToolCallActor = OpenApiSchemas['ToolCall']['actor'];
+export type V1ToolCallCallerType = OpenApiSchemas['ToolCall']['callerType'];
 export type V1ToolCallStatus = OpenApiSchemas['ToolCall']['status'];
-export type V1ToolCallTool = OpenApiSchemas['ToolCallTool'];
+export type V1ToolName = OpenApiSchemas['ToolCall']['tool'];
 export type V1ToolCall = OpenApiSchemas['ToolCall'];
 export type V1ToolCallListQuery = OpenApiQuery<'tool-calls.list'>;

package/dist/toolCalls.d.ts

@@ -1,9 +1,12 @@
 import type { V1HttpClient } from './http.js';
-import type { V1ListEnvelope, V1ToolCall, V1ToolCallListQuery } from './types.js';
+import type { JsonValue, V1ListEnvelope, V1ToolCall, V1ToolCallListQuery, V1ToolCallResultQuery } 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>;
+    cancel(toolCallId: string): Promise<V1ToolCall>;
+    respond(toolCallId: string, response: JsonValue): Promise<V1ToolCall>;
+    result(toolCallId: string, query?: V1ToolCallResultQuery): Promise<JsonValue | V1ToolCall>;
 }