@inferencesh/sdk 0.6.15 → 0.6.19

package/dist/api/tasks.test.js

@@ -1,381 +0,0 @@
-import { HttpClient } from '../http/client';
-import { TaskStatusCancelled, TaskStatusCompleted, TaskStatusFailed, TaskStatusRunning, } from '../types';
-import { TasksAPI } from './tasks';
-const mockFetch = jest.fn();
-global.fetch = mockFetch;
-function mockJsonResponse(body) {
-    mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        text: () => Promise.resolve(JSON.stringify(body)),
-    });
-}
-function makeTask(overrides = {}) {
-    return {
-        id: 'task-1',
-        status: TaskStatusRunning,
-        created_at: '2026-01-01T00:00:00Z',
-        updated_at: '2026-01-01T00:00:00Z',
-        input: { prompt: 'hi' },
-        output: null,
-        logs: [],
-        session_id: 'sess-1',
-        ...overrides,
-    };
-}
-describe('TasksAPI.run (polling mode)', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new TasksAPI(new HttpClient({
-        apiKey: 'test-key',
-        stream: false,
-        pollIntervalMs: 20,
-    }));
-    it('should resolve when status polling detects completion', async () => {
-        const runningTask = makeTask();
-        const completedTask = makeTask({ status: TaskStatusCompleted, output: { ok: true } });
-        mockJsonResponse(runningTask);
-        mockJsonResponse({ status: TaskStatusRunning });
-        mockJsonResponse({ status: TaskStatusCompleted });
-        mockJsonResponse(completedTask);
-        const onUpdate = jest.fn();
-        const result = await api().run({ app: 'test-app', input: {} }, { prompt: 'hi' }, { wait: true, stream: false, onUpdate });
-        expect(result.status).toBe(TaskStatusCompleted);
-        expect(onUpdate).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: TaskStatusCompleted }));
-    });
-    it('should reject when polling detects a failed task', async () => {
-        const runningTask = makeTask();
-        const failedTask = makeTask({ status: TaskStatusFailed, error: 'model error' });
-        mockJsonResponse(runningTask);
-        mockJsonResponse({ status: TaskStatusRunning });
-        mockJsonResponse({ status: TaskStatusFailed });
-        mockJsonResponse(failedTask);
-        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true, stream: false })).rejects.toThrow('model error');
-    });
-    it('should reject when polling detects a cancelled task', async () => {
-        const runningTask = makeTask();
-        const cancelledTask = makeTask({ status: TaskStatusCancelled });
-        mockJsonResponse(runningTask);
-        mockJsonResponse({ status: TaskStatusRunning });
-        mockJsonResponse({ status: TaskStatusCancelled });
-        mockJsonResponse(cancelledTask);
-        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true, stream: false })).rejects.toThrow('task cancelled');
-    });
-    it('should reject when full task fetch fails after status change', async () => {
-        const runningTask = makeTask();
-        mockJsonResponse(runningTask);
-        mockJsonResponse({ status: TaskStatusRunning });
-        mockJsonResponse({ status: TaskStatusCompleted });
-        mockFetch.mockRejectedValueOnce(new Error('network down'));
-        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true, stream: false })).rejects.toThrow('network down');
-    });
-    it('should reject when status polling fails', async () => {
-        const runningTask = makeTask();
-        mockJsonResponse(runningTask);
-        mockFetch.mockRejectedValueOnce(new Error('status endpoint down'));
-        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true, stream: false })).rejects.toThrow('status endpoint down');
-    });
-    it('should not refetch full task when poll status is unchanged', async () => {
-        const runningTask = makeTask();
-        const completedTask = makeTask({ status: TaskStatusCompleted, output: { ok: true } });
-        mockJsonResponse(runningTask);
-        mockJsonResponse({ status: TaskStatusRunning });
-        mockJsonResponse({ status: TaskStatusRunning });
-        mockJsonResponse({ status: TaskStatusCompleted });
-        mockJsonResponse(completedTask);
-        await api().run({ app: 'test-app', input: {} }, {}, { wait: true, stream: false });
-        const fullTaskGets = mockFetch.mock.calls.filter(([url, init]) => String(url).includes('/tasks/task-1') &&
-            !String(url).includes('/status') &&
-            init.method === 'GET');
-        expect(fullTaskGets).toHaveLength(1);
-    });
-    it('should parse string terminal statuses from the status endpoint', async () => {
-        const runningTask = makeTask();
-        const completedTask = makeTask({ status: TaskStatusCompleted });
-        mockJsonResponse(runningTask);
-        mockJsonResponse({ status: TaskStatusRunning });
-        mockJsonResponse({ status: 'completed' });
-        mockJsonResponse(completedTask);
-        const result = await api().run({ app: 'test-app', input: {} }, {}, { wait: true, stream: false });
-        expect(result.status).toBe(TaskStatusCompleted);
-    });
-});
-function mockNdjsonStream(chunks) {
-    let chunkIndex = 0;
-    const mockReader = {
-        read: jest.fn().mockImplementation(async () => {
-            if (chunkIndex >= chunks.length) {
-                return { done: true, value: undefined };
-            }
-            return { done: false, value: new TextEncoder().encode(chunks[chunkIndex++]) };
-        }),
-        releaseLock: jest.fn(),
-    };
-    return {
-        ok: true,
-        status: 200,
-        body: { getReader: () => mockReader },
-    };
-}
-describe('TasksAPI.run (general)', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const streamingApi = () => new TasksAPI(new HttpClient({ apiKey: 'test-key', stream: true }));
-    it('should return immediately when wait is false', async () => {
-        const task = makeTask();
-        mockJsonResponse(task);
-        const result = await streamingApi().run({ app: 'test-app', input: {} }, { prompt: 'hi' }, { wait: false });
-        expect(result.id).toBe('task-1');
-        expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
-});
-describe('TasksAPI.run (streaming mode)', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new TasksAPI(new HttpClient({ apiKey: 'test-key', stream: true }));
-    function setupStreamMocks(ndjsonChunks, initialTask = makeTask()) {
-        mockFetch.mockImplementation((url) => {
-            if (url.includes('/apps/run')) {
-                return Promise.resolve({
-                    ok: true,
-                    status: 200,
-                    text: () => Promise.resolve(JSON.stringify(initialTask)),
-                });
-            }
-            return Promise.resolve(mockNdjsonStream(ndjsonChunks));
-        });
-    }
-    it('should resolve when NDJSON stream reports completion', async () => {
-        setupStreamMocks([
-            `${JSON.stringify({ status: TaskStatusRunning, id: 'task-1' })}\n`,
-            `${JSON.stringify({ status: TaskStatusCompleted, id: 'task-1', output: { ok: true } })}\n`,
-        ]);
-        const onUpdate = jest.fn();
-        const result = await api().run({ app: 'test-app', input: {} }, { prompt: 'hi' }, { wait: true, onUpdate });
-        expect(result.status).toBe(TaskStatusCompleted);
-        expect(onUpdate).toHaveBeenCalled();
-    });
-    it('should reject when NDJSON stream reports failure', async () => {
-        setupStreamMocks([
-            `${JSON.stringify({ status: TaskStatusFailed, id: 'task-1', error: 'gpu OOM' })}\n`,
-        ]);
-        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true })).rejects.toThrow('gpu OOM');
-    });
-    it('should reject when NDJSON stream reports cancellation', async () => {
-        setupStreamMocks([
-            `${JSON.stringify({ status: TaskStatusCancelled, id: 'task-1' })}\n`,
-        ]);
-        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true })).rejects.toThrow('task cancelled');
-    });
-    it('should reject when partial stream reports failure', async () => {
-        setupStreamMocks([
-            `${JSON.stringify({
-                data: { status: TaskStatusFailed, id: 'task-1', error: 'partial fail' },
-                fields: ['status'],
-            })}\n`,
-        ]);
-        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true })).rejects.toThrow('partial fail');
-    });
-    it('should reject when partial stream reports cancellation', async () => {
-        setupStreamMocks([
-            `${JSON.stringify({
-                data: { status: TaskStatusCancelled, id: 'task-1' },
-                fields: ['status'],
-            })}\n`,
-        ]);
-        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true })).rejects.toThrow('task cancelled');
-    });
-    it('should reject when the NDJSON stream connection fails', async () => {
-        mockFetch.mockImplementation((url) => {
-            if (url.includes('/apps/run')) {
-                return Promise.resolve({
-                    ok: true,
-                    status: 200,
-                    text: () => Promise.resolve(JSON.stringify(makeTask())),
-                });
-            }
-            return Promise.resolve({
-                ok: false,
-                status: 503,
-                text: () => Promise.resolve('service unavailable'),
-            });
-        });
-        await expect(api().run({ app: 'test-app', input: {} }, {}, { wait: true })).rejects.toThrow('HTTP 503');
-    });
-    it('should handle partial updates via onPartialUpdate', async () => {
-        setupStreamMocks([
-            `${JSON.stringify({
-                data: { status: TaskStatusCompleted, id: 'task-1', session_id: 'sess-1' },
-                fields: ['status'],
-            })}\n`,
-        ]);
-        const onPartialUpdate = jest.fn();
-        const result = await api().run({ app: 'test-app', input: {} }, {}, { wait: true, onPartialUpdate });
-        expect(result.status).toBe(TaskStatusCompleted);
-        expect(onPartialUpdate).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: TaskStatusCompleted }), ['status']);
-    });
-    it('should preserve session_id across partial stream updates that omit it', async () => {
-        setupStreamMocks([
-            `${JSON.stringify({
-                data: { status: TaskStatusRunning, id: 'task-1' },
-                fields: ['status'],
-            })}\n`,
-            `${JSON.stringify({
-                data: { status: TaskStatusCompleted, id: 'task-1', output: { ok: true } },
-                fields: ['status', 'output'],
-            })}\n`,
-        ], makeTask({ session_id: 'sess-persist' }));
-        const onPartialUpdate = jest.fn();
-        const result = await api().run({ app: 'test-app', input: {} }, {}, { wait: true, onPartialUpdate });
-        expect(result.session_id).toBe('sess-persist');
-        expect(onPartialUpdate).toHaveBeenCalledWith(expect.objectContaining({ session_id: 'sess-persist', status: TaskStatusRunning }), ['status']);
-        expect(onPartialUpdate).toHaveBeenLastCalledWith(expect.objectContaining({
-            session_id: 'sess-persist',
-            status: TaskStatusCompleted,
-            output: { ok: true },
-        }), ['status', 'output']);
-    });
-});
-describe('TasksAPI.run (HTTP contract)', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new TasksAPI(new HttpClient({ apiKey: 'test-key' }));
-    it('should POST /apps/run with merged params and processedInput', async () => {
-        const task = makeTask();
-        mockJsonResponse(task);
-        const result = await api().run({ app: 'image-gen', version_id: 'ver-2', input: {} }, { prompt: 'sunset', width: 512 }, { wait: false });
-        expect(result).toEqual(task);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/run');
-        expect(init.method).toBe('POST');
-        expect(JSON.parse(init.body)).toEqual({
-            app: 'image-gen',
-            version_id: 'ver-2',
-            input: { prompt: 'sunset', width: 512 },
-        });
-    });
-});
-describe('TasksAPI.create', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new TasksAPI(new HttpClient({ apiKey: 'test-key' }));
-    it('should POST /apps/run for create()', async () => {
-        const task = makeTask();
-        mockJsonResponse(task);
-        const result = await api().create({ app: 'test-app', input: { prompt: 'hi' } });
-        expect(result).toEqual(task);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/apps/run');
-        expect(init.method).toBe('POST');
-        expect(JSON.parse(init.body)).toEqual({
-            app: 'test-app',
-            input: { prompt: 'hi' },
-        });
-    });
-});
-describe('TasksAPI (CRUD and admin)', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new TasksAPI(new HttpClient({ apiKey: 'test-key' }));
-    it('should POST /tasks/list for list()', async () => {
-        const page = { items: [{ id: 'task-1' }], next_cursor: null };
-        mockJsonResponse(page);
-        const result = await api().list({ limit: 5 });
-        expect(result).toEqual(page);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/tasks/list');
-        expect(init.method).toBe('POST');
-        expect(JSON.parse(init.body)).toEqual({ limit: 5 });
-    });
-    it('should GET /tasks/featured for listFeatured()', async () => {
-        const page = { items: [{ id: 'task-f' }], next_cursor: null };
-        mockJsonResponse(page);
-        const result = await api().listFeatured({ cursor: 'abc' });
-        expect(result).toEqual(page);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/tasks/featured');
-        expect(init.method).toBe('GET');
-    });
-    it('should GET /tasks/{id} for get()', async () => {
-        const task = makeTask();
-        mockJsonResponse(task);
-        const result = await api().get('task-1');
-        expect(result).toEqual(task);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/tasks/task-1');
-        expect(init.method).toBe('GET');
-    });
-    it('should DELETE /tasks/{id} for delete()', async () => {
-        mockJsonResponse(null);
-        await api().delete('task-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/tasks/task-1');
-        expect(init.method).toBe('DELETE');
-    });
-    it('should POST /tasks/{id}/cancel for cancel()', async () => {
-        mockJsonResponse(null);
-        await api().cancel('task-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/tasks/task-1/cancel');
-        expect(init.method).toBe('POST');
-    });
-    it('should POST visibility for updateVisibility()', async () => {
-        const task = makeTask({ visibility: 'public' });
-        mockJsonResponse(task);
-        const result = await api().updateVisibility('task-1', 'public');
-        expect(result).toEqual(task);
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ visibility: 'public' });
-    });
-    it('should POST is_featured for feature()', async () => {
-        const task = makeTask({ is_featured: true });
-        mockJsonResponse(task);
-        await api().feature('task-1', true);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/tasks/task-1/featured');
-        expect(JSON.parse(init.body)).toEqual({ is_featured: true });
-    });
-    it('should open SSE on /tasks/{id}/stream for stream()', async () => {
-        const http = new HttpClient({ apiKey: 'test-key' });
-        const createEventSource = jest
-            .spyOn(http, 'createEventSource')
-            .mockResolvedValue(null);
-        const tasks = new TasksAPI(http);
-        await tasks.stream('task-42');
-        expect(createEventSource).toHaveBeenCalledWith('/tasks/task-42/stream');
-        createEventSource.mockRestore();
-    });
-    it('should GET /tasks/{id}/logs for getLogs()', async () => {
-        const logs = { logs: [{ message: 'started', timestamp: '2026-01-01T00:00:00Z' }] };
-        mockJsonResponse(logs);
-        const result = await api().getLogs('task-1');
-        expect(result).toEqual(logs);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/tasks/task-1/logs');
-        expect(init.method).toBe('GET');
-    });
-    it('should GET /tasks/{id}/timings for getTimings()', async () => {
-        const timings = { total_ms: 1200, stages: [{ name: 'inference', ms: 900 }] };
-        mockJsonResponse(timings);
-        const result = await api().getTimings('task-1');
-        expect(result).toEqual(timings);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/tasks/task-1/timings');
-        expect(init.method).toBe('GET');
-    });
-    it('should GET /tasks/{id}/telemetry for getTelemetry()', async () => {
-        const telemetry = [{ metric: 'gpu_util', value: 0.82 }];
-        mockJsonResponse(telemetry);
-        const result = await api().getTelemetry('task-1');
-        expect(result).toEqual(telemetry);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/tasks/task-1/telemetry');
-        expect(init.method).toBe('GET');
-    });
-});

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

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

package/dist/api/teams.test.js

@@ -1,139 +0,0 @@
-import { HttpClient } from '../http/client';
-import { TeamsAPI } from './teams';
-const mockFetch = jest.fn();
-global.fetch = mockFetch;
-function mockJsonResponse(body) {
-    mockFetch.mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        text: () => Promise.resolve(JSON.stringify(body)),
-    });
-}
-describe('TeamsAPI', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    const api = () => new TeamsAPI(new HttpClient({ apiKey: 'test-key' }));
-    it('should GET /me for me()', async () => {
-        const me = { user: { id: 'user-1' }, team: { id: 'team-1' } };
-        mockJsonResponse(me);
-        const result = await api().me();
-        expect(result).toEqual(me);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/me');
-        expect(init.method).toBe('GET');
-    });
-    it('should GET /teams for list()', async () => {
-        const teams = [{ id: 'team-1', name: 'Acme' }];
-        mockJsonResponse(teams);
-        const result = await api().list();
-        expect(result).toEqual(teams);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams');
-        expect(init.method).toBe('GET');
-    });
-    it('should POST /teams for create()', async () => {
-        const payload = { name: 'New Team', username: 'new-team' };
-        const team = { id: 'team-new', ...payload };
-        mockJsonResponse(team);
-        const result = await api().create(payload);
-        expect(result).toEqual(team);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams');
-        expect(init.method).toBe('POST');
-        expect(JSON.parse(init.body)).toEqual(payload);
-    });
-    it('should GET /teams/check-username with username param for checkUsername()', async () => {
-        mockJsonResponse({ available: true });
-        const result = await api().checkUsername('acme-corp');
-        expect(result).toEqual({ available: true });
-        const [url] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams/check-username');
-        expect(url).toContain('username=acme-corp');
-    });
-    it('should POST role for updateMemberRole()', async () => {
-        const member = { user_id: 'user-2', role: 'admin' };
-        mockJsonResponse(member);
-        await api().updateMemberRole('team-1', 'user-2', 'admin');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams/team-1/members/user-2/role');
-        expect(JSON.parse(init.body)).toEqual({ role: 'admin' });
-    });
-    it('should DELETE /teams/{id}/members/{userId} for removeMember()', async () => {
-        mockJsonResponse(null);
-        await api().removeMember('team-1', 'user-3');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams/team-1/members/user-3');
-        expect(init.method).toBe('DELETE');
-    });
-    it('should POST /teams/{id}/invites for createInvite()', async () => {
-        const payload = { email: 'dev@example.com', role: 'member' };
-        const invite = { id: 'inv-1', ...payload };
-        mockJsonResponse(invite);
-        const result = await api().createInvite('team-1', payload);
-        expect(result).toEqual(invite);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams/team-1/invites');
-        expect(JSON.parse(init.body)).toEqual(payload);
-    });
-    it('should GET /teams/{id} for get()', async () => {
-        const team = { id: 'team-1', name: 'Acme' };
-        mockJsonResponse(team);
-        const result = await api().get('team-1');
-        expect(result).toEqual(team);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams/team-1');
-        expect(init.method).toBe('GET');
-    });
-    it('should POST /teams/{id} for update()', async () => {
-        const team = { id: 'team-1', name: 'Acme Updated' };
-        mockJsonResponse(team);
-        const result = await api().update('team-1', { name: 'Acme Updated' });
-        expect(result).toEqual(team);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams/team-1');
-        expect(JSON.parse(init.body)).toEqual({ name: 'Acme Updated' });
-    });
-    it('should DELETE /teams/{id} for delete()', async () => {
-        mockJsonResponse(null);
-        await api().delete('team-1');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams/team-1');
-        expect(init.method).toBe('DELETE');
-    });
-    it('should GET /teams/{id}/members for getMembers()', async () => {
-        const members = [{ user_id: 'user-1', role: 'owner' }];
-        mockJsonResponse(members);
-        const result = await api().getMembers('team-1');
-        expect(result).toEqual(members);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams/team-1/members');
-        expect(init.method).toBe('GET');
-    });
-    it('should POST /teams/{id}/members for addMember()', async () => {
-        const payload = { user_id: 'user-4', role: 'member' };
-        const member = { ...payload };
-        mockJsonResponse(member);
-        const result = await api().addMember('team-1', payload);
-        expect(result).toEqual(member);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams/team-1/members');
-        expect(JSON.parse(init.body)).toEqual(payload);
-    });
-    it('should GET /teams/{id}/invites for listInvites()', async () => {
-        const invites = [{ id: 'inv-1', email: 'dev@example.com' }];
-        mockJsonResponse(invites);
-        const result = await api().listInvites('team-1');
-        expect(result).toEqual(invites);
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams/team-1/invites');
-        expect(init.method).toBe('GET');
-    });
-    it('should DELETE /teams/{id}/invites/{inviteId} for revokeInvite()', async () => {
-        mockJsonResponse(null);
-        await api().revokeInvite('team-1', 'inv-9');
-        const [url, init] = mockFetch.mock.calls[0];
-        expect(url).toContain('/teams/team-1/invites/inv-9');
-        expect(init.method).toBe('DELETE');
-    });
-});

package/dist/client.test.d.ts

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