@inferencesh/sdk 0.6.8 → 0.6.12

package/dist/api/projects.js

@@ -0,0 +1,38 @@
+/**
+ * Projects API
+ */
+export class ProjectsAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List projects with cursor-based pagination
+     */
+    async list(params) {
+        return this.http.request('post', '/projects/list', { data: params });
+    }
+    /**
+     * Get a project by ID
+     */
+    async get(id) {
+        return this.http.request('get', `/projects/${id}`);
+    }
+    /**
+     * Create a project
+     */
+    async create(data) {
+        return this.http.request('post', '/projects', { data });
+    }
+    /**
+     * Update a project
+     */
+    async update(id, data) {
+        return this.http.request('post', `/projects/${id}`, { data });
+    }
+    /**
+     * Delete a project
+     */
+    async delete(id) {
+        return this.http.request('delete', `/projects/${id}`);
+    }
+}

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

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

package/dist/api/projects.test.js

@@ -0,0 +1,52 @@
+import { HttpClient } from '../http/client';
+import { ProjectsAPI } from './projects';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('ProjectsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new ProjectsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /projects/list for list()', async () => {
+        const page = { items: [{ id: 'proj-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list({ limit: 20 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/projects/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /projects/{id} for get()', async () => {
+        const project = { id: 'proj-1', name: 'Demo' };
+        mockJsonResponse(project);
+        const result = await api().get('proj-1');
+        expect(result).toEqual(project);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/projects/proj-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /projects for create()', async () => {
+        const payload = { name: 'New Project' };
+        const project = { id: 'proj-new', ...payload };
+        mockJsonResponse(project);
+        const result = await api().create(payload);
+        expect(result).toEqual(project);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/projects');
+        expect(init.method).toBe('POST');
+    });
+    it('should DELETE /projects/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('proj-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/projects/proj-1');
+        expect(init.method).toBe('DELETE');
+    });
+});

package/dist/api/search.d.ts

@@ -0,0 +1,21 @@
+import { HttpClient } from '../http/client';
+import { SuggestRequest, SuggestResponse } from '../types';
+/**
+ * Search API
+ */
+export declare class SearchAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Unified search across skills, knowledge, and apps
+     */
+    suggest(params: Partial<SuggestRequest>): Promise<SuggestResponse>;
+    /**
+     * Full-text search via Meilisearch
+     */
+    search(params: {
+        q: string;
+        type?: string;
+        limit?: number;
+    }): Promise<unknown>;
+}

package/dist/api/search.js

@@ -0,0 +1,20 @@
+/**
+ * Search API
+ */
+export class SearchAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Unified search across skills, knowledge, and apps
+     */
+    async suggest(params) {
+        return this.http.request('post', '/suggest', { data: params });
+    }
+    /**
+     * Full-text search via Meilisearch
+     */
+    async search(params) {
+        return this.http.request('post', '/search', { data: params });
+    }
+}

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

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

package/dist/api/search.test.js

@@ -0,0 +1,39 @@
+import { HttpClient } from '../http/client';
+import { SearchAPI } from './search';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('SearchAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new SearchAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /suggest for suggest()', async () => {
+        const payload = { query: 'image gen', types: ['apps', 'skills'] };
+        const response = { results: [{ type: 'app', id: 'app-1' }] };
+        mockJsonResponse(response);
+        const result = await api().suggest(payload);
+        expect(result).toEqual(response);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/suggest');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+    it('should POST /search for search()', async () => {
+        const payload = { q: 'claude', type: 'apps', limit: 5 };
+        const response = { hits: [{ id: 'app-1' }] };
+        mockJsonResponse(response);
+        const result = await api().search(payload);
+        expect(result).toEqual(response);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/search');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+});

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

@@ -16,7 +16,7 @@ describe('SessionsAPI', () => {
     const api = () => new SessionsAPI(new HttpClient({ apiKey: 'test-key' }));
     it('should GET /sessions/{id} for get()', async () => {
         const session = { id: 'sess_1', status: 'active' };
-        mockJsonResponse({ success: true, data: session });
+        mockJsonResponse(session);
         const result = await api().get('sess_1');
         expect(result).toEqual(session);
         const [url, init] = mockFetch.mock.calls[0];
@@ -24,7 +24,7 @@ describe('SessionsAPI', () => {
         expect(init.method).toBe('GET');
     });
     it('should return an empty array when list() response is null', async () => {
-        mockJsonResponse({ success: true, data: null });
+        mockJsonResponse(null);
         const result = await api().list();
         expect(result).toEqual([]);
         const [url] = mockFetch.mock.calls[0];
@@ -32,7 +32,7 @@ describe('SessionsAPI', () => {
     });
     it('should POST /sessions/{id}/keepalive for keepalive()', async () => {
         const session = { id: 'sess_2', status: 'active' };
-        mockJsonResponse({ success: true, data: session });
+        mockJsonResponse(session);
         const result = await api().keepalive('sess_2');
         expect(result).toEqual(session);
         const [url, init] = mockFetch.mock.calls[0];
@@ -40,7 +40,7 @@ describe('SessionsAPI', () => {
         expect(init.method).toBe('POST');
     });
     it('should DELETE /sessions/{id} for end()', async () => {
-        mockJsonResponse({ success: true, data: null });
+        mockJsonResponse(null);
         await api().end('sess_3');
         const [url, init] = mockFetch.mock.calls[0];
         expect(url).toContain('/sessions/sess_3');

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

@@ -35,10 +35,10 @@ describe('TasksAPI.run (polling mode)', () => {
     it('should resolve when status polling detects completion', async () => {
         const runningTask = makeTask();
         const completedTask = makeTask({ status: TaskStatusCompleted, output: { ok: true } });
-        mockJsonResponse({ success: true, data: runningTask });
-        mockJsonResponse({ success: true, data: { status: TaskStatusRunning } });
-        mockJsonResponse({ success: true, data: { status: TaskStatusCompleted } });
-        mockJsonResponse({ success: true, data: completedTask });
+        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);
@@ -47,42 +47,56 @@ describe('TasksAPI.run (polling mode)', () => {
     it('should reject when polling detects a failed task', async () => {
         const runningTask = makeTask();
         const failedTask = makeTask({ status: TaskStatusFailed, error: 'model error' });
-        mockJsonResponse({ success: true, data: runningTask });
-        mockJsonResponse({ success: true, data: { status: TaskStatusRunning } });
-        mockJsonResponse({ success: true, data: { status: TaskStatusFailed } });
-        mockJsonResponse({ success: true, data: failedTask });
+        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({ success: true, data: runningTask });
-        mockJsonResponse({ success: true, data: { status: TaskStatusRunning } });
-        mockJsonResponse({ success: true, data: { status: TaskStatusCancelled } });
-        mockJsonResponse({ success: true, data: cancelledTask });
+        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({ success: true, data: runningTask });
-        mockJsonResponse({ success: true, data: { status: TaskStatusRunning } });
-        mockJsonResponse({ success: true, data: { status: TaskStatusCompleted } });
+        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({ success: true, data: runningTask });
+        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({ success: true, data: runningTask });
-        mockJsonResponse({ success: true, data: { status: TaskStatusRunning } });
-        mockJsonResponse({ success: true, data: { status: 'completed' } });
-        mockJsonResponse({ success: true, data: completedTask });
+        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);
     });
@@ -111,7 +125,7 @@ describe('TasksAPI.run (general)', () => {
     const streamingApi = () => new TasksAPI(new HttpClient({ apiKey: 'test-key', stream: true }));
     it('should return immediately when wait is false', async () => {
         const task = makeTask();
-        mockJsonResponse({ success: true, data: task });
+        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);
@@ -128,7 +142,7 @@ describe('TasksAPI.run (streaming mode)', () => {
                 return Promise.resolve({
                     ok: true,
                     status: 200,
-                    text: () => Promise.resolve(JSON.stringify({ success: true, data: initialTask })),
+                    text: () => Promise.resolve(JSON.stringify(initialTask)),
                 });
             }
             return Promise.resolve(mockNdjsonStream(ndjsonChunks));
@@ -156,6 +170,24 @@ describe('TasksAPI.run (streaming mode)', () => {
         ]);
         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 handle partial updates via onPartialUpdate', async () => {
         setupStreamMocks([
             `${JSON.stringify({
@@ -169,3 +201,123 @@ describe('TasksAPI.run (streaming mode)', () => {
         expect(onPartialUpdate).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: TaskStatusCompleted }), ['status']);
     });
 });
+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');
+    });
+});