@inferencesh/sdk 0.6.8 → 0.6.12

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

package/dist/api/teams.test.js

@@ -0,0 +1,79 @@
+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);
+    });
+});

package/dist/client.test.js

@@ -38,7 +38,7 @@ describe('Inference', () => {
                 input: { message: 'hello world' },
                 output: { result: 'success' },
             };
-            const responseData = { success: true, data: mockTask };
+            const responseData = mockTask;
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 status: 200,
@@ -58,7 +58,7 @@ describe('Inference', () => {
             }));
         });
         it('should throw error on API failure', async () => {
-            const responseData = { success: false, error: { message: 'Invalid app' } };
+            const responseData = { message: 'Invalid app' };
             mockFetch.mockResolvedValueOnce({
                 ok: false,
                 status: 400,
@@ -141,7 +141,7 @@ describe('Inference', () => {
     });
     describe('cancel', () => {
         it('should make a POST request to cancel endpoint', async () => {
-            const responseData = { success: true, data: null };
+            const responseData = null;
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 status: 200,
@@ -185,7 +185,7 @@ describe('namespaced APIs', () => {
                 updated_at: new Date().toISOString(),
                 input: { message: 'hello world' },
             };
-            const responseData = { success: true, data: mockTask };
+            const responseData = mockTask;
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 status: 200,
@@ -202,7 +202,7 @@ describe('namespaced APIs', () => {
         });
         it('should get task via tasks.get()', async () => {
             const mockTask = { id: 'task-123', status: 7 };
-            const responseData = { success: true, data: mockTask };
+            const responseData = mockTask;
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 status: 200,
@@ -215,7 +215,7 @@ describe('namespaced APIs', () => {
             expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/tasks/task-123'), expect.objectContaining({ method: 'GET' }));
         });
         it('should cancel task via tasks.cancel()', async () => {
-            const responseData = { success: true, data: null };
+            const responseData = null;
             mockFetch.mockResolvedValueOnce({
                 ok: true,
                 status: 200,
@@ -298,7 +298,7 @@ describe('uploadFile', () => {
             uri: 'https://example.com/file.png',
             upload_url: 'https://upload.example.com/signed-url',
         };
-        const responseData = { success: true, data: [mockFile] };
+        const responseData = [mockFile];
         mockFetch
             .mockResolvedValueOnce({
             ok: true,
@@ -322,7 +322,7 @@ describe('uploadFile', () => {
             uri: 'https://example.com/file.png',
             // Missing upload_url
         };
-        const responseData = { success: true, data: [mockFile] };
+        const responseData = [mockFile];
         mockFetch.mockResolvedValueOnce({
             ok: true,
             status: 200,

package/dist/http/client.d.ts

@@ -84,6 +84,11 @@ export declare class HttpClient {
         url: string;
         headers: Record<string, string>;
     };
+    /**
+     * Pull a human-readable detail string from a parsed problem+json / API error
+     * body (RFC 9457 `detail`/`title`, or a plain `message`).
+     */
+    private extractErrorDetail;
     /**
      * Create an EventSource for SSE streaming
      * @deprecated Use getStreamableConfig() with StreamableManager instead

package/dist/http/client.js

@@ -16,7 +16,7 @@ export class HttpClient {
         this.baseUrl = config.baseUrl || 'https://api.inference.sh';
         this.proxyUrl = config.proxyUrl;
         this.getToken = config.getToken;
-        this.customHeaders = { 'X-Client-Source': 'inference-sdk-js/0.5.13', ...config.headers };
+        this.customHeaders = { 'X-Client-Source': 'inference-sdk-js/0.5.13', 'X-API-Version': '2', ...config.headers };
         this.credentials = config.credentials || 'include';
         this.onError = config.onError;
         this.streamDefault = config.stream ?? true;
@@ -114,7 +114,6 @@ export class HttpClient {
         }
         const response = await fetch(fetchUrl, fetchOptions);
         const responseText = await response.text();
-        // Try to parse as JSON
         let data = null;
         try {
             data = JSON.parse(responseText);
@@ -122,44 +121,24 @@ export class HttpClient {
         catch {
             // Not JSON
         }
-        // Check for HTTP errors
+        // HTTP errors → RFC 9457 problem+json
         if (!response.ok) {
-            // Check for RequirementsNotMetException (412 with errors array)
             if (response.status === 412 && data && 'errors' in data && Array.isArray(data.errors)) {
                 throw RequirementsNotMetException.fromResponse(data, response.status);
             }
-            // General error handling
             let errorDetail;
             if (data && typeof data === 'object') {
-                const apiData = data;
-                if (apiData.error) {
-                    errorDetail = typeof apiData.error === 'object' ? apiData.error.message : String(apiData.error);
-                }
-                else if ('message' in data) {
-                    errorDetail = String(data.message);
-                }
-                else {
-                    errorDetail = JSON.stringify(data);
-                }
+                errorDetail = this.extractErrorDetail(data) ?? JSON.stringify(data);
             }
             else if (responseText) {
                 errorDetail = responseText.slice(0, 500);
             }
             throw new InferenceError(response.status, errorDetail || 'Request failed', responseText);
         }
-        // Handle 204 No Content (e.g., DELETE requests)
-        if (response.status === 204) {
+        if (response.status === 204 || !responseText) {
             return undefined;
         }
-        const apiResponse = data;
-        if (!apiResponse?.success) {
-            let errorMessage = apiResponse?.error?.message;
-            if (!errorMessage) {
-                errorMessage = `Request failed (success=false). Response: ${responseText.slice(0, 500)}`;
-            }
-            throw new InferenceError(response.status, errorMessage, responseText);
-        }
-        return (apiResponse.data ?? null);
+        return data;
     }
     /**
      * Get URL and headers for NDJSON streaming.
@@ -185,6 +164,16 @@ export class HttpClient {
         }
         return { url, headers };
     }
+    /**
+     * Pull a human-readable detail string from a parsed problem+json / API error
+     * body (RFC 9457 `detail`/`title`, or a plain `message`).
+     */
+    extractErrorDetail(data) {
+        if (!data || typeof data !== 'object')
+            return undefined;
+        const d = data;
+        return (d.detail || d.title || d.message);
+    }
     /**
      * Create an EventSource for SSE streaming
      * @deprecated Use getStreamableConfig() with StreamableManager instead
@@ -204,30 +193,39 @@ export class HttpClient {
             fetchUrl = targetUrl.toString();
         }
         const resolvedHeaders = this.resolveHeaders();
-        return Promise.resolve(new EventSource(fetchUrl, {
-            fetch: (input, init) => {
-                const headers = {
-                    ...init?.headers,
-                    ...resolvedHeaders,
-                };
-                if (isProxyMode) {
-                    // Proxy mode: also send target URL as header (for non-browser clients)
-                    headers['x-inf-target-url'] = targetUrl.toString();
+        // The EventSource error event omits the response body, so a failed initial
+        // connection (e.g. 403 otp_required) is handled here in the fetch wrapper:
+        // route it through onError like request() does, and hand the retried
+        // response (e.g. after OTP verification) back so the stream connects.
+        const doFetch = async (input, init) => {
+            const headers = {
+                ...init?.headers,
+                ...resolvedHeaders,
+            };
+            if (isProxyMode) {
+                headers['x-inf-target-url'] = targetUrl.toString();
+            }
+            else {
+                const token = this.getAuthToken();
+                if (token) {
+                    headers['Authorization'] = `Bearer ${token}`;
                 }
-                else {
-                    // Direct mode: include authorization header
-                    const token = this.getAuthToken();
-                    if (token) {
-                        headers['Authorization'] = `Bearer ${token}`;
-                    }
+            }
+            const response = await fetch(input, { ...init, headers, credentials: this.credentials });
+            if (!response.ok && this.onError) {
+                const body = await response.clone().text().catch(() => '');
+                let data;
+                try {
+                    data = JSON.parse(body);
                 }
-                return fetch(input, {
-                    ...init,
-                    headers,
-                    credentials: this.credentials,
-                });
-            },
-        }));
+                catch { /* non-JSON body */ }
+                const error = new InferenceError(response.status, this.extractErrorDetail(data) ?? 'Request failed', body);
+                const handled = await this.onError(error, () => doFetch(input, init));
+                return handled ?? response;
+            }
+            return response;
+        };
+        return Promise.resolve(new EventSource(fetchUrl, { fetch: doFetch }));
     }
 }
 /**