@inferencesh/sdk 0.6.10 → 0.6.13

package/dist/api/secrets.d.ts

@@ -0,0 +1,29 @@
+import { HttpClient } from '../http/client';
+import { SecretDTO, SecretCreateRequest, CursorListRequest, CursorListResponse } from '../types';
+/**
+ * Secrets API
+ */
+export declare class SecretsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List secrets with cursor-based pagination
+     */
+    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<SecretDTO>>;
+    /**
+     * Create a secret
+     */
+    create(data: SecretCreateRequest): Promise<SecretDTO>;
+    /**
+     * Update a secret
+     */
+    update(key: string, data: Partial<SecretCreateRequest>): Promise<SecretDTO>;
+    /**
+     * Delete a secret
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Reveal a secret value
+     */
+    reveal(key: string): Promise<SecretDTO>;
+}

package/dist/api/secrets.js

@@ -0,0 +1,38 @@
+/**
+ * Secrets API
+ */
+export class SecretsAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List secrets with cursor-based pagination
+     */
+    async list(params) {
+        return this.http.request('post', '/secrets/list', { data: params });
+    }
+    /**
+     * Create a secret
+     */
+    async create(data) {
+        return this.http.request('post', '/secrets', { data });
+    }
+    /**
+     * Update a secret
+     */
+    async update(key, data) {
+        return this.http.request('put', `/secrets/${key}`, { data });
+    }
+    /**
+     * Delete a secret
+     */
+    async delete(key) {
+        return this.http.request('delete', `/secrets/${key}`);
+    }
+    /**
+     * Reveal a secret value
+     */
+    async reveal(key) {
+        return this.http.request('get', `/secrets/reveal/${key}`);
+    }
+}

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

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

package/dist/api/secrets.test.js

@@ -0,0 +1,61 @@
+import { HttpClient } from '../http/client';
+import { SecretsAPI } from './secrets';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('SecretsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new SecretsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /secrets/list for list()', async () => {
+        const page = { items: [{ key: 'API_KEY' }], 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('/secrets/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST /secrets for create()', async () => {
+        const payload = { key: 'DB_PASSWORD', value: 'secret' };
+        const secret = { key: 'DB_PASSWORD' };
+        mockJsonResponse(secret);
+        const result = await api().create(payload);
+        expect(result).toEqual(secret);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/secrets');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+    it('should PUT /secrets/{key} for update()', async () => {
+        const secret = { key: 'DB_PASSWORD' };
+        mockJsonResponse(secret);
+        await api().update('DB_PASSWORD', { value: 'new-secret' });
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/secrets/DB_PASSWORD');
+        expect(init.method).toBe('PUT');
+    });
+    it('should GET /secrets/reveal/{key} for reveal()', async () => {
+        const secret = { key: 'API_KEY', value: 'sk-live-abc' };
+        mockJsonResponse(secret);
+        const result = await api().reveal('API_KEY');
+        expect(result).toEqual(secret);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/secrets/reveal/API_KEY');
+        expect(init.method).toBe('GET');
+    });
+    it('should DELETE /secrets/{key} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('OLD_KEY');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/secrets/OLD_KEY');
+        expect(init.method).toBe('DELETE');
+    });
+});

package/dist/api/sessions.test.js

@@ -23,6 +23,18 @@ describe('SessionsAPI', () => {
         expect(url).toContain('/sessions/sess_1');
         expect(init.method).toBe('GET');
     });
+    it('should GET /sessions and return session list', async () => {
+        const sessions = [
+            { id: 'sess_1', status: 'active' },
+            { id: 'sess_2', status: 'active' },
+        ];
+        mockJsonResponse(sessions);
+        const result = await api().list();
+        expect(result).toEqual(sessions);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/sessions');
+        expect(init.method).toBe('GET');
+    });
     it('should return an empty array when list() response is null', async () => {
         mockJsonResponse(null);
         const result = await api().list();

package/dist/api/tasks.d.ts

@@ -1,5 +1,5 @@
 import { HttpClient } from '../http/client';
-import { TaskDTO as Task, ApiAppRunRequest, CursorListRequest, CursorListResponse } from '../types';
+import { TaskDTO as Task, TaskLogsDTO, TaskTimingsDTO, ApiAppRunRequest, CursorListRequest, CursorListResponse } from '../types';
 export interface RunOptions {
     /** Callback for real-time status updates */
     onUpdate?: (update: Task) => void;
@@ -62,5 +62,17 @@ export declare class TasksAPI {
      * Feature/unfeature a task
      */
     feature(taskId: string, featured: boolean): Promise<Task>;
+    /**
+     * Get task logs
+     */
+    getLogs(taskId: string): Promise<TaskLogsDTO>;
+    /**
+     * Get task timings
+     */
+    getTimings(taskId: string): Promise<TaskTimingsDTO>;
+    /**
+     * Get task telemetry
+     */
+    getTelemetry(taskId: string): Promise<Record<string, unknown>[]>;
 }
 export declare function createTasksAPI(http: HttpClient): TasksAPI;

package/dist/api/tasks.js

@@ -193,6 +193,24 @@ export class TasksAPI {
     async feature(taskId, featured) {
         return this.http.request('post', `/tasks/${taskId}/featured`, { data: { is_featured: featured } });
     }
+    /**
+     * Get task logs
+     */
+    async getLogs(taskId) {
+        return this.http.request('get', `/tasks/${taskId}/logs`);
+    }
+    /**
+     * Get task timings
+     */
+    async getTimings(taskId) {
+        return this.http.request('get', `/tasks/${taskId}/timings`);
+    }
+    /**
+     * Get task telemetry
+     */
+    async getTelemetry(taskId) {
+        return this.http.request('get', `/tasks/${taskId}/telemetry`);
+    }
 }
 export function createTasksAPI(http) {
     return new TasksAPI(http);

package/dist/api/tasks.test.js

@@ -76,6 +76,20 @@ describe('TasksAPI.run (polling mode)', () => {
         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 });
@@ -174,6 +188,23 @@ describe('TasksAPI.run (streaming mode)', () => {
         ]);
         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({
@@ -187,3 +218,143 @@ describe('TasksAPI.run (streaming mode)', () => {
         expect(onPartialUpdate).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: TaskStatusCompleted }), ['status']);
     });
 });
+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.d.ts

@@ -0,0 +1,71 @@
+import { HttpClient } from '../http/client';
+import { UserDTO, TeamRelationDTO, TeamMemberDTO, TeamInviteDTO, TeamCreateRequest, TeamMemberAddRequest, TeamInviteCreateRequest } from '../types';
+export interface MeResponse {
+    user: UserDTO;
+    team?: TeamRelationDTO;
+}
+/**
+ * Teams API
+ */
+export declare class TeamsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Get current user and team context
+     */
+    me(): Promise<MeResponse>;
+    /**
+     * List user's teams
+     */
+    list(): Promise<TeamRelationDTO[]>;
+    /**
+     * Get a team by ID
+     */
+    get(teamId: string): Promise<TeamRelationDTO>;
+    /**
+     * Create a new team
+     */
+    create(data: TeamCreateRequest): Promise<TeamRelationDTO>;
+    /**
+     * Update a team
+     */
+    update(teamId: string, data: Partial<TeamCreateRequest>): Promise<TeamRelationDTO>;
+    /**
+     * Delete a team
+     */
+    delete(teamId: string): Promise<void>;
+    /**
+     * Check username availability
+     */
+    checkUsername(username: string): Promise<{
+        available: boolean;
+    }>;
+    /**
+     * Get team members
+     */
+    getMembers(teamId: string): Promise<TeamMemberDTO[]>;
+    /**
+     * Add a team member
+     */
+    addMember(teamId: string, data: TeamMemberAddRequest): Promise<TeamMemberDTO>;
+    /**
+     * Remove a team member
+     */
+    removeMember(teamId: string, userId: string): Promise<void>;
+    /**
+     * Update a member's role
+     */
+    updateMemberRole(teamId: string, userId: string, role: string): Promise<TeamMemberDTO>;
+    /**
+     * List team invites
+     */
+    listInvites(teamId: string): Promise<TeamInviteDTO[]>;
+    /**
+     * Create an invite
+     */
+    createInvite(teamId: string, data: TeamInviteCreateRequest): Promise<TeamInviteDTO>;
+    /**
+     * Revoke an invite
+     */
+    revokeInvite(teamId: string, inviteId: string): Promise<void>;
+}

package/dist/api/teams.js

@@ -0,0 +1,92 @@
+/**
+ * Teams API
+ */
+export class TeamsAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Get current user and team context
+     */
+    async me() {
+        return this.http.request('get', '/me');
+    }
+    /**
+     * List user's teams
+     */
+    async list() {
+        return this.http.request('get', '/teams');
+    }
+    /**
+     * Get a team by ID
+     */
+    async get(teamId) {
+        return this.http.request('get', `/teams/${teamId}`);
+    }
+    /**
+     * Create a new team
+     */
+    async create(data) {
+        return this.http.request('post', '/teams', { data });
+    }
+    /**
+     * Update a team
+     */
+    async update(teamId, data) {
+        return this.http.request('post', `/teams/${teamId}`, { data });
+    }
+    /**
+     * Delete a team
+     */
+    async delete(teamId) {
+        return this.http.request('delete', `/teams/${teamId}`);
+    }
+    /**
+     * Check username availability
+     */
+    async checkUsername(username) {
+        return this.http.request('get', '/teams/check-username', { params: { username } });
+    }
+    /**
+     * Get team members
+     */
+    async getMembers(teamId) {
+        return this.http.request('get', `/teams/${teamId}/members`);
+    }
+    /**
+     * Add a team member
+     */
+    async addMember(teamId, data) {
+        return this.http.request('post', `/teams/${teamId}/members`, { data });
+    }
+    /**
+     * Remove a team member
+     */
+    async removeMember(teamId, userId) {
+        return this.http.request('delete', `/teams/${teamId}/members/${userId}`);
+    }
+    /**
+     * Update a member's role
+     */
+    async updateMemberRole(teamId, userId, role) {
+        return this.http.request('post', `/teams/${teamId}/members/${userId}/role`, { data: { role } });
+    }
+    /**
+     * List team invites
+     */
+    async listInvites(teamId) {
+        return this.http.request('get', `/teams/${teamId}/invites`);
+    }
+    /**
+     * Create an invite
+     */
+    async createInvite(teamId, data) {
+        return this.http.request('post', `/teams/${teamId}/invites`, { data });
+    }
+    /**
+     * Revoke an invite
+     */
+    async revokeInvite(teamId, inviteId) {
+        return this.http.request('delete', `/teams/${teamId}/invites/${inviteId}`);
+    }
+}

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

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