@inferencesh/sdk 0.6.10 → 0.6.12

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
      */

package/dist/api/flows.test.js

@@ -40,4 +40,79 @@ describe('FlowsAPI', () => {
         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 {};