@inferencesh/sdk 0.6.10 → 0.6.13

package/dist/api/apps.test.js

@@ -48,12 +48,13 @@ describe('AppsAPI', () => {
         const [, init] = mockFetch.mock.calls[0];
         expect(JSON.parse(init.body)).toEqual({ license: 'key-abc' });
     });
-    it('should POST version_id for setCurrentVersion()', async () => {
+    it('should PUT /apps/{id}/versions/{versionId}/current for setCurrentVersion()', async () => {
         const app = { id: 'app-1', current_version_id: 'ver-2' };
         mockJsonResponse(app);
         await api().setCurrentVersion('app-1', 'ver-2');
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ version_id: 'ver-2' });
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/versions/ver-2/current');
+        expect(init.method).toBe('PUT');
     });
     it('should POST /apps/{id}/duplicate for duplicate()', async () => {
         const app = { id: 'app-copy' };
@@ -64,4 +65,71 @@ describe('AppsAPI', () => {
         expect(url).toContain('/apps/app-1/duplicate');
         expect(init.method).toBe('POST');
     });
+    it('should GET /apps/{id} for get()', async () => {
+        const app = { id: 'app-1', name: 'demo' };
+        mockJsonResponse(app);
+        const result = await api().get('app-1');
+        expect(result).toEqual(app);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should GET versioned app for getByVersionId()', async () => {
+        const app = { id: 'app-1', version_id: 'ver-1' };
+        mockJsonResponse(app);
+        const result = await api().getByVersionId('app-1', 'ver-1');
+        expect(result).toEqual(app);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/versions/ver-1');
+    });
+    it('should POST /apps for create()', async () => {
+        const app = { id: 'app-new', name: 'New App' };
+        mockJsonResponse(app);
+        const result = await api().create({ name: 'New App' });
+        expect(result).toEqual(app);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ name: 'New App' });
+    });
+    it('should POST /apps/{id} for update()', async () => {
+        const app = { id: 'app-1', description: 'updated' };
+        mockJsonResponse(app);
+        const result = await api().update('app-1', { description: 'updated' });
+        expect(result).toEqual(app);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1');
+        expect(JSON.parse(init.body)).toEqual({ description: 'updated' });
+    });
+    it('should DELETE /apps/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('app-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /apps/{id}/versions/list for listVersions()', async () => {
+        const versions = { items: [{ id: 'ver-1' }], next_cursor: null };
+        mockJsonResponse(versions);
+        const result = await api().listVersions('app-1', { limit: 20 });
+        expect(result).toEqual(versions);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/versions/list');
+        expect(JSON.parse(init.body)).toEqual({ limit: 20 });
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const app = { id: 'app-1', visibility: 'private' };
+        mockJsonResponse(app);
+        await api().updateVisibility('app-1', 'private');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'private' });
+    });
+    it('should GET /apps/{id}/license for getLicense()', async () => {
+        const license = { app_id: 'app-1', license: 'MIT' };
+        mockJsonResponse(license);
+        const result = await api().getLicense('app-1');
+        expect(result).toEqual(license);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/license');
+    });
 });

package/dist/api/chats.d.ts

@@ -26,5 +26,19 @@ export declare class ChatsAPI {
      * Get chat trace (for debugging/observability)
      */
     getTrace(chatId: string): Promise<ChatTraceDTO>;
+    /**
+     * Get chat status
+     */
+    getStatus(chatId: string): Promise<{
+        status: string;
+    }>;
+    /**
+     * Stop chat generation
+     */
+    stop(chatId: string): Promise<void>;
+    /**
+     * Stream chat updates
+     */
+    stream(chatId: string): Promise<import("eventsource").EventSource | null>;
 }
 export declare function createChatsAPI(http: HttpClient): ChatsAPI;

package/dist/api/chats.js

@@ -35,6 +35,24 @@ export class ChatsAPI {
     async getTrace(chatId) {
         return this.http.request('get', `/chats/${chatId}/trace`);
     }
+    /**
+     * Get chat status
+     */
+    async getStatus(chatId) {
+        return this.http.request('get', `/chats/${chatId}/status`);
+    }
+    /**
+     * Stop chat generation
+     */
+    async stop(chatId) {
+        return this.http.request('post', `/chats/${chatId}/stop`);
+    }
+    /**
+     * Stream chat updates
+     */
+    stream(chatId) {
+        return this.http.createEventSource(`/chats/${chatId}/stream`);
+    }
 }
 export function createChatsAPI(http) {
     return new ChatsAPI(http);

package/dist/api/chats.test.js

@@ -30,4 +30,56 @@ describe('ChatsAPI', () => {
         expect(url).toContain('/chats/chat-9');
         expect(init.method).toBe('DELETE');
     });
+    it('should POST /chats/list for list()', async () => {
+        const page = { items: [{ id: 'chat-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list({ limit: 25 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/list');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ limit: 25 });
+    });
+    it('should GET /chats/{id} for get()', async () => {
+        const chat = { id: 'chat-1', status: 'open' };
+        mockJsonResponse(chat);
+        const result = await api().get('chat-1');
+        expect(result).toEqual(chat);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /chats/{id} for update()', async () => {
+        const chat = { id: 'chat-1', name: 'Renamed' };
+        mockJsonResponse(chat);
+        const result = await api().update('chat-1', { name: 'Renamed' });
+        expect(result).toEqual(chat);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'Renamed' });
+    });
+    it('should GET /chats/{id}/status for getStatus()', async () => {
+        mockJsonResponse({ status: 'busy' });
+        const result = await api().getStatus('chat-1');
+        expect(result).toEqual({ status: 'busy' });
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-1/status');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /chats/{id}/stop for stop()', async () => {
+        mockJsonResponse(null);
+        await api().stop('chat-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-1/stop');
+        expect(init.method).toBe('POST');
+    });
+    it('should open SSE on /chats/{id}/stream for stream()', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const createEventSource = jest
+            .spyOn(http, 'createEventSource')
+            .mockResolvedValue(null);
+        const chats = new ChatsAPI(http);
+        await chats.stream('chat-42');
+        expect(createEventSource).toHaveBeenCalledWith('/chats/chat-42/stream');
+        createEventSource.mockRestore();
+    });
 });

package/dist/api/engines.d.ts

@@ -53,5 +53,17 @@ export declare class EnginesAPI {
      * Transfer engine ownership
      */
     transferOwnership(engineId: string, newTeamId: string): Promise<Engine>;
+    /**
+     * Extend engine duration
+     */
+    extend(engineId: string): Promise<void>;
+    /**
+     * Drain an engine
+     */
+    drain(engineId: string): Promise<void>;
+    /**
+     * Update an engine binary (drain + restart with new version)
+     */
+    updateBinary(engineId: string): Promise<void>;
 }
 export declare function createEnginesAPI(http: HttpClient): EnginesAPI;

package/dist/api/engines.js

@@ -71,6 +71,24 @@ export class EnginesAPI {
     async transferOwnership(engineId, newTeamId) {
         return this.http.request('post', `/engines/${engineId}/transfer`, { data: { team_id: newTeamId } });
     }
+    /**
+     * Extend engine duration
+     */
+    async extend(engineId) {
+        return this.http.request('post', `/engines/${engineId}/extend`);
+    }
+    /**
+     * Drain an engine
+     */
+    async drain(engineId) {
+        return this.http.request('post', `/engines/${engineId}/drain`);
+    }
+    /**
+     * Update an engine binary (drain + restart with new version)
+     */
+    async updateBinary(engineId) {
+        return this.http.request('post', `/engines/${engineId}/update`);
+    }
 }
 export function createEnginesAPI(http) {
     return new EnginesAPI(http);

package/dist/api/engines.test.js

@@ -52,4 +52,82 @@ describe('EnginesAPI', () => {
         expect(createEventSource).toHaveBeenCalledWith('/engines/eng-7/stream');
         createEventSource.mockRestore();
     });
+    it('should POST /engines/list for list()', async () => {
+        const page = { items: [{ id: 'eng-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list();
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /engines/{id} for get()', async () => {
+        const engine = { id: 'eng-1' };
+        mockJsonResponse(engine);
+        const result = await api().get('eng-1');
+        expect(result).toEqual(engine);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /engines for create()', async () => {
+        const engine = { id: 'eng-new', name: 'worker' };
+        mockJsonResponse(engine);
+        const result = await api().create({ name: 'worker' });
+        expect(result).toEqual(engine);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ name: 'worker' });
+    });
+    it('should POST /engines/{id} for update()', async () => {
+        const engine = { id: 'eng-1', name: 'updated' };
+        mockJsonResponse(engine);
+        const result = await api().update('eng-1', { name: 'updated' });
+        expect(result).toEqual(engine);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'updated' });
+    });
+    it('should DELETE /engines/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('eng-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const engine = { id: 'eng-1', visibility: 'team' };
+        mockJsonResponse(engine);
+        await api().updateVisibility('eng-1', 'team');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'team' });
+    });
+    it('should POST transfer with team_id for transferOwnership()', async () => {
+        const engine = { id: 'eng-1' };
+        mockJsonResponse(engine);
+        await api().transferOwnership('eng-1', 'team-7');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-7' });
+    });
+    it('should POST /engines/{id}/extend for extend()', async () => {
+        mockJsonResponse(null);
+        await api().extend('eng-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1/extend');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST /engines/{id}/drain for drain()', async () => {
+        mockJsonResponse(null);
+        await api().drain('eng-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1/drain');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST /engines/{id}/update for updateBinary()', async () => {
+        mockJsonResponse(null);
+        await api().updateBinary('eng-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1/update');
+        expect(init.method).toBe('POST');
+    });
 });

package/dist/api/files.test.js

@@ -14,6 +14,32 @@ describe('FilesAPI', () => {
         jest.clearAllMocks();
     });
     const api = () => new FilesAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /files/list for list()', async () => {
+        const page = { items: [{ id: 'file-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list({ limit: 10 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/files/list');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ limit: 10 });
+    });
+    it('should GET /files/{id} for get()', async () => {
+        const file = { id: 'file-1', uri: 'inf://files/abc' };
+        mockJsonResponse(file);
+        const result = await api().get('file-1');
+        expect(result).toEqual(file);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/files/file-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should DELETE /files/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('file-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/files/file-1');
+        expect(init.method).toBe('DELETE');
+    });
     describe('processInput', () => {
         it('should not treat short plain strings as base64 file uploads', async () => {
             const result = await api().processInput({ key: 'key1', note: 'hello' });
@@ -38,12 +64,169 @@ describe('FilesAPI', () => {
             expect(result.image).toBe('inf://files/abc');
             expect(mockFetch).toHaveBeenCalledTimes(2);
         });
+        it('should upload top-level Blob values', async () => {
+            const fileRecord = {
+                id: 'file-blob',
+                uri: 'inf://files/blob',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'image/png',
+            };
+            mockJsonResponse([fileRecord]);
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const blob = new Blob(['png-bytes'], { type: 'image/png' });
+            const result = await api().processInput(blob);
+            expect(result).toBe('inf://files/blob');
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+        });
+        it('should process arrays recursively', async () => {
+            const fileRecord = {
+                id: 'file-arr',
+                uri: 'inf://files/arr',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'image/png',
+            };
+            mockJsonResponse([fileRecord]);
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const input = ['plain', 'data:image/png;base64,iVBORw0KGgo='];
+            const result = (await api().processInput(input));
+            expect(result[0]).toBe('plain');
+            expect(result[1]).toBe('inf://files/arr');
+        });
+        it('should upload long raw base64 strings', async () => {
+            const fileRecord = {
+                id: 'file-b64',
+                uri: 'inf://files/b64',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'application/octet-stream',
+            };
+            mockJsonResponse([fileRecord]);
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const rawBase64 = 'A'.repeat(64);
+            const result = await api().processInput(rawBase64);
+            expect(result).toBe('inf://files/b64');
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+        });
     });
     describe('upload', () => {
         it('should reject invalid data URI format when uploading content', async () => {
             mockJsonResponse([{ id: 'file-x', uri: '', upload_url: 'https://upload.example.com/put' }]);
             await expect(api().upload('data:invalid')).rejects.toThrow('Invalid data URI format');
         });
+        it('should decode URL-encoded (non-base64) data URIs', async () => {
+            const fileRecord = {
+                id: 'file-3',
+                uri: 'inf://files/url-encoded',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'text/plain',
+            };
+            mockJsonResponse([fileRecord]);
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const result = await api().upload('data:text/plain,Hello%20World');
+            expect(result.uri).toBe('inf://files/url-encoded');
+            const putCall = mockFetch.mock.calls[1];
+            expect(putCall[1]?.headers).toMatchObject({ 'Content-Type': 'text/plain' });
+        });
+        it('should default media type to text/plain for data URIs without explicit type', async () => {
+            const fileRecord = {
+                id: 'file-4',
+                uri: 'inf://files/default-mt',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'text/plain',
+            };
+            mockJsonResponse([fileRecord]);
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            await api().upload('data:;base64,SGVsbG8=');
+            const putCall = mockFetch.mock.calls[1];
+            expect(putCall[1]?.headers).toMatchObject({ 'Content-Type': 'text/plain' });
+        });
+        it('should throw when server does not return upload_url', async () => {
+            mockJsonResponse([{ id: 'file-x', uri: '', upload_url: undefined }]);
+            await expect(api().upload('data:text/plain,hello')).rejects.toThrow('No upload URL provided by the server');
+        });
+        it('should throw when PUT to upload_url fails', async () => {
+            const fileRecord = {
+                id: 'file-5',
+                uri: 'inf://files/fail-put',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'text/plain',
+            };
+            mockJsonResponse([fileRecord]);
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                statusText: 'Internal Server Error',
+            });
+            await expect(api().upload('data:text/plain,hello')).rejects.toThrow('Failed to upload file content');
+        });
+        it('should upload Blob content with inferred content type and size', async () => {
+            const fileRecord = {
+                id: 'file-blob',
+                uri: 'inf://files/blob-direct',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'image/jpeg',
+            };
+            mockJsonResponse([fileRecord]);
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const blob = new Blob(['jpeg-bytes'], { type: 'image/jpeg' });
+            const result = await api().upload(blob, { filename: 'photo.jpg' });
+            expect(result.uri).toBe('inf://files/blob-direct');
+            const [, createInit] = mockFetch.mock.calls[0];
+            const createBody = JSON.parse(createInit.body);
+            expect(createBody.files[0]).toMatchObject({
+                filename: 'photo.jpg',
+                content_type: 'image/jpeg',
+                size: blob.size,
+            });
+            const [, putInit] = mockFetch.mock.calls[1];
+            expect(putInit.method).toBe('PUT');
+            expect(putInit.body).toBe(blob);
+            expect(putInit.headers).toMatchObject({ 'Content-Type': 'image/jpeg' });
+        });
+        it('should extract filename from File objects when options.filename is omitted', async () => {
+            const fileRecord = {
+                id: 'file-named',
+                uri: 'inf://files/named',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'application/pdf',
+            };
+            mockJsonResponse([fileRecord]);
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const file = new File(['pdf-bytes'], 'report.pdf', { type: 'application/pdf' });
+            await api().upload(file);
+            const [, createInit] = mockFetch.mock.calls[0];
+            const createBody = JSON.parse(createInit.body);
+            expect(createBody.files[0].filename).toBe('report.pdf');
+            expect(createBody.files[0].content_type).toBe('application/pdf');
+        });
+        it('should use explicit contentType when Blob type is empty', async () => {
+            const fileRecord = {
+                id: 'file-octet',
+                uri: 'inf://files/octet',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'application/octet-stream',
+            };
+            mockJsonResponse([fileRecord]);
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const blob = new Blob(['raw']);
+            await api().upload(blob, { contentType: 'application/octet-stream' });
+            const [, createInit] = mockFetch.mock.calls[0];
+            const createBody = JSON.parse(createInit.body);
+            expect(createBody.files[0].content_type).toBe('application/octet-stream');
+        });
+        it('should upload clean base64 strings without a data URI prefix', async () => {
+            const fileRecord = {
+                id: 'file-b64-direct',
+                uri: 'inf://files/b64-direct',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'text/plain',
+            };
+            mockJsonResponse([fileRecord]);
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const result = await api().upload('SGVsbG8=', { contentType: 'text/plain' });
+            expect(result.uri).toBe('inf://files/b64-direct');
+            const [, putInit] = mockFetch.mock.calls[1];
+            expect(putInit.headers).toMatchObject({ 'Content-Type': 'text/plain' });
+        });
         it('should decode URL-safe base64 in data URIs', async () => {
             const fileRecord = {
                 id: 'file-2',

package/dist/api/flow-runs.test.js

@@ -52,4 +52,46 @@ describe('FlowRunsAPI', () => {
         expect(createEventSource).toHaveBeenCalledWith('/flowruns/fr-42/tasks/stream');
         createEventSource.mockRestore();
     });
+    it('should POST /flowruns/list for list()', async () => {
+        const page = { items: [{ id: 'fr-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list({ limit: 10 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flowruns/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /flowruns/{id} for get()', async () => {
+        const flowRun = { id: 'fr-1' };
+        mockJsonResponse(flowRun);
+        const result = await api().get('fr-1');
+        expect(result).toEqual(flowRun);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flowruns/fr-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /flowruns/{id}/clone for clone()', async () => {
+        const flowRun = { id: 'fr-clone' };
+        mockJsonResponse(flowRun);
+        const result = await api().clone('fr-1');
+        expect(result).toEqual(flowRun);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flowruns/fr-1/clone');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST /flowruns/{id} for update()', async () => {
+        const flowRun = { id: 'fr-1', fail_on_error: false };
+        mockJsonResponse(flowRun);
+        const result = await api().update('fr-1', { fail_on_error: false });
+        expect(result).toEqual(flowRun);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ fail_on_error: false });
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const flowRun = { id: 'fr-1', visibility: 'public' };
+        mockJsonResponse(flowRun);
+        await api().updateVisibility('fr-1', 'public');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'public' });
+    });
 });

package/dist/api/flows.d.ts

@@ -22,6 +22,10 @@ export declare class FlowsAPI {
      * Update a flow
      */
     update(flowId: string, data: Partial<Flow>): Promise<Flow>;
+    /**
+     * Update flow visibility
+     */
+    updateVisibility(flowId: string, visibility: string): Promise<Flow>;
     /**
      * Delete a flow
      */

package/dist/api/flows.js

@@ -29,6 +29,12 @@ export class FlowsAPI {
     async update(flowId, data) {
         return this.http.request('post', `/flows/${flowId}`, { data });
     }
+    /**
+     * Update flow visibility
+     */
+    async updateVisibility(flowId, visibility) {
+        return this.http.request('post', `/flows/${flowId}/visibility`, { data: { visibility } });
+    }
     /**
      * Delete a flow
      */