@inferencesh/sdk 0.6.8 → 0.6.12

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' });
@@ -27,7 +53,7 @@ describe('FilesAPI', () => {
                 upload_url: 'https://upload.example.com/put',
                 content_type: 'image/png',
             };
-            mockJsonResponse({ success: true, data: [fileRecord] });
+            mockJsonResponse([fileRecord]);
             mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
             const input = {
                 prompt: 'draw',
@@ -38,15 +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({
-                success: true,
-                data: [{ id: 'file-x', uri: '', upload_url: 'https://upload.example.com/put' }],
-            });
+            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',
@@ -54,7 +234,7 @@ describe('FilesAPI', () => {
                 upload_url: 'https://upload.example.com/put',
                 content_type: 'text/plain',
             };
-            mockJsonResponse({ success: true, data: [fileRecord] });
+            mockJsonResponse([fileRecord]);
             mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
             // "SGVsbG8" is "Hello" in standard base64; URL-safe variant uses '-' instead of '+'
             const dataUri = 'data:text/plain;base64,SGVsbG8';

package/dist/api/flow-runs.test.d.ts

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

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

@@ -0,0 +1,97 @@
+import { HttpClient } from '../http/client';
+import { FlowRunsAPI } from './flow-runs';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('FlowRunsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new FlowRunsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST flow and input for create()', async () => {
+        const flowRun = { id: 'fr-1', flow: 'flow-1' };
+        mockJsonResponse(flowRun);
+        const result = await api().create('flow-1', { prompt: 'hi' });
+        expect(result).toEqual(flowRun);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({
+            flow: 'flow-1',
+            input: { prompt: 'hi' },
+        });
+    });
+    it('should POST /flowruns/{id}/cancel for cancel()', async () => {
+        mockJsonResponse(null);
+        await api().cancel('fr-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flowruns/fr-1/cancel');
+        expect(init.method).toBe('POST');
+    });
+    it('should open SSE on /flowruns/{id}/stream for stream()', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const createEventSource = jest
+            .spyOn(http, 'createEventSource')
+            .mockResolvedValue(null);
+        const flowRuns = new FlowRunsAPI(http);
+        await flowRuns.stream('fr-42');
+        expect(createEventSource).toHaveBeenCalledWith('/flowruns/fr-42/stream');
+        createEventSource.mockRestore();
+    });
+    it('should open task SSE for streamTasks()', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const createEventSource = jest
+            .spyOn(http, 'createEventSource')
+            .mockResolvedValue(null);
+        const flowRuns = new FlowRunsAPI(http);
+        await flowRuns.streamTasks('fr-42');
+        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
      */

package/dist/api/flows.test.d.ts

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

package/dist/api/flows.test.js

@@ -0,0 +1,118 @@
+import { HttpClient } from '../http/client';
+import { FlowsAPI } from './flows';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('FlowsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new FlowsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST name for create()', async () => {
+        const flow = { id: 'flow-1', name: 'My Flow' };
+        mockJsonResponse(flow);
+        const result = await api().create('My Flow');
+        expect(result).toEqual(flow);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'My Flow' });
+    });
+    it('should POST /flows/{id}/app for createApp()', async () => {
+        const app = { id: 'app-from-flow' };
+        mockJsonResponse(app);
+        const result = await api().createApp('flow-1');
+        expect(result).toEqual(app);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1/app');
+    });
+    it('should open SSE on /flows/{id}/stream for stream()', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const createEventSource = jest
+            .spyOn(http, 'createEventSource')
+            .mockResolvedValue(null);
+        const flows = new FlowsAPI(http);
+        await flows.stream('flow-5');
+        expect(createEventSource).toHaveBeenCalledWith('/flows/flow-5/stream');
+        createEventSource.mockRestore();
+    });
+    it('should POST /flows/list for list()', async () => {
+        const page = { items: [{ id: 'flow-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('/flows/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /flows/{id} for get()', async () => {
+        const flow = { id: 'flow-1', name: 'Demo' };
+        mockJsonResponse(flow);
+        const result = await api().get('flow-1');
+        expect(result).toEqual(flow);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /flows/{id} for update()', async () => {
+        const flow = { id: 'flow-1', name: 'Renamed' };
+        mockJsonResponse(flow);
+        const result = await api().update('flow-1', { name: 'Renamed' });
+        expect(result).toEqual(flow);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'Renamed' });
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const flow = { id: 'flow-1', visibility: 'public' };
+        mockJsonResponse(flow);
+        const result = await api().updateVisibility('flow-1', 'public');
+        expect(result).toEqual(flow);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1/visibility');
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'public' });
+    });
+    it('should DELETE /flows/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('flow-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /flows/{id}/duplicate for duplicate()', async () => {
+        const flow = { id: 'flow-copy' };
+        mockJsonResponse(flow);
+        const result = await api().duplicate('flow-1');
+        expect(result).toEqual(flow);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1/duplicate');
+    });
+    it('should POST /flows/{id}/versions/list for listVersions()', async () => {
+        const versions = { items: [{ id: 'ver-1' }], next_cursor: null };
+        mockJsonResponse(versions);
+        const result = await api().listVersions('flow-1');
+        expect(result).toEqual(versions);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1/versions/list');
+    });
+    it('should POST transfer with team_id for transferOwnership()', async () => {
+        const flow = { id: 'flow-1' };
+        mockJsonResponse(flow);
+        await api().transferOwnership('flow-1', 'team-42');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-42' });
+    });
+    it('should POST /flows/{id}/visibility for updateVisibility()', async () => {
+        const flow = { id: 'flow-1', visibility: 'public' };
+        mockJsonResponse(flow);
+        const result = await api().updateVisibility('flow-1', 'public');
+        expect(result).toEqual(flow);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1/visibility');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'public' });
+    });
+});

package/dist/api/integrations.d.ts

@@ -0,0 +1,41 @@
+import { HttpClient } from '../http/client';
+import { IntegrationDTO, IntegrationConfigDTO, IntegrationConnectRequest, IntegrationConnectResponse, CursorListRequest, CursorListResponse } from '../types';
+/**
+ * Integrations API
+ */
+export declare class IntegrationsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List integrations with cursor-based pagination
+     */
+    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<IntegrationDTO>>;
+    /**
+     * Get available integrations
+     */
+    listAvailable(): Promise<IntegrationConfigDTO[]>;
+    /**
+     * Get integration configs
+     */
+    getConfigs(): Promise<IntegrationConfigDTO[]>;
+    /**
+     * Get capabilities
+     */
+    getCapabilities(): Promise<unknown>;
+    /**
+     * Check requirements
+     */
+    checkRequirements(data: unknown): Promise<unknown>;
+    /**
+     * Connect an integration
+     */
+    connect(data: IntegrationConnectRequest): Promise<IntegrationConnectResponse>;
+    /**
+     * Get an integration by provider key
+     */
+    get(provider: string): Promise<IntegrationDTO>;
+    /**
+     * Disconnect an integration
+     */
+    disconnect(provider: string): Promise<void>;
+}

package/dist/api/integrations.js

@@ -0,0 +1,56 @@
+/**
+ * Integrations API
+ */
+export class IntegrationsAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List integrations with cursor-based pagination
+     */
+    async list(params) {
+        return this.http.request('post', '/integrations/list', { data: params });
+    }
+    /**
+     * Get available integrations
+     */
+    async listAvailable() {
+        return this.http.request('get', '/integrations/available');
+    }
+    /**
+     * Get integration configs
+     */
+    async getConfigs() {
+        return this.http.request('get', '/integrations/configs');
+    }
+    /**
+     * Get capabilities
+     */
+    async getCapabilities() {
+        return this.http.request('get', '/integrations/capabilities');
+    }
+    /**
+     * Check requirements
+     */
+    async checkRequirements(data) {
+        return this.http.request('post', '/integrations/check', { data });
+    }
+    /**
+     * Connect an integration
+     */
+    async connect(data) {
+        return this.http.request('post', '/integrations', { data });
+    }
+    /**
+     * Get an integration by provider key
+     */
+    async get(provider) {
+        return this.http.request('get', `/integrations/${provider}`);
+    }
+    /**
+     * Disconnect an integration
+     */
+    async disconnect(provider) {
+        return this.http.request('delete', `/integrations/${provider}`);
+    }
+}

package/dist/api/integrations.test.d.ts

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