@inferencesh/sdk 0.6.10 → 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/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 });
@@ -187,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');
+    });
+});

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 {};