@inferencesh/sdk 0.6.7 → 0.6.10

package/dist/api/apps.test.js

@@ -0,0 +1,67 @@
+import { HttpClient } from '../http/client';
+import { AppsAPI } from './apps';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('AppsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new AppsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /apps/list for list()', async () => {
+        const apps = { items: [{ id: 'app-1' }], next_cursor: null };
+        mockJsonResponse(apps);
+        const result = await api().list({ limit: 10 });
+        expect(result).toEqual(apps);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/list');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ limit: 10 });
+    });
+    it('should GET /apps/{name} for getByName()', async () => {
+        const app = { id: 'app-1', name: 'inference/claude-haiku' };
+        mockJsonResponse(app);
+        const result = await api().getByName('inference/claude-haiku');
+        expect(result).toEqual(app);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/inference/claude-haiku');
+    });
+    it('should POST transfer with team_id for transferOwnership()', async () => {
+        const app = { id: 'app-1' };
+        mockJsonResponse(app);
+        await api().transferOwnership('app-1', 'team-99');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/transfer');
+        expect(JSON.parse(init.body)).toEqual({ team_id: 'team-99' });
+    });
+    it('should POST license payload for saveLicense()', async () => {
+        const license = { app_id: 'app-1', license: 'key-abc' };
+        mockJsonResponse(license);
+        const result = await api().saveLicense('app-1', 'key-abc');
+        expect(result).toEqual(license);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ license: 'key-abc' });
+    });
+    it('should POST version_id for setCurrentVersion()', async () => {
+        const app = { id: 'app-1', current_version_id: 'ver-2' };
+        mockJsonResponse(app);
+        await api().setCurrentVersion('app-1', 'ver-2');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ version_id: 'ver-2' });
+    });
+    it('should POST /apps/{id}/duplicate for duplicate()', async () => {
+        const app = { id: 'app-copy' };
+        mockJsonResponse(app);
+        const result = await api().duplicate('app-1');
+        expect(result).toEqual(app);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/duplicate');
+        expect(init.method).toBe('POST');
+    });
+});

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

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

package/dist/api/chats.test.js

@@ -0,0 +1,33 @@
+import { HttpClient } from '../http/client';
+import { ChatsAPI } from './chats';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('ChatsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new ChatsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should GET /chats/{id}/trace for getTrace()', async () => {
+        const trace = { chat_id: 'chat-1', spans: [] };
+        mockJsonResponse(trace);
+        const result = await api().getTrace('chat-1');
+        expect(result).toEqual(trace);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-1/trace');
+        expect(init.method).toBe('GET');
+    });
+    it('should DELETE /chats/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('chat-9');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-9');
+        expect(init.method).toBe('DELETE');
+    });
+});

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

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

package/dist/api/engines.test.js

@@ -0,0 +1,55 @@
+import { HttpClient } from '../http/client';
+import { EnginesAPI } from './engines';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('EnginesAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new EnginesAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST resource ids for getForResources()', async () => {
+        const engines = [{ id: 'eng-1' }];
+        mockJsonResponse(engines);
+        const result = await api().getForResources({
+            app_ids: ['app-1'],
+            agent_ids: ['agent-1'],
+        });
+        expect(result).toEqual(engines);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/resources');
+        expect(JSON.parse(init.body)).toEqual({
+            app_ids: ['app-1'],
+            agent_ids: ['agent-1'],
+        });
+    });
+    it('should POST /engines/{id}/stop for stop()', async () => {
+        mockJsonResponse(null);
+        await api().stop('eng-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1/stop');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST /engines/{id}/restart for restart()', async () => {
+        mockJsonResponse(null);
+        await api().restart('eng-1');
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/engines/eng-1/restart');
+    });
+    it('should open SSE on /engines/{id}/stream for stream()', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const createEventSource = jest
+            .spyOn(http, 'createEventSource')
+            .mockResolvedValue(null);
+        const engines = new EnginesAPI(http);
+        await engines.stream('eng-7');
+        expect(createEventSource).toHaveBeenCalledWith('/engines/eng-7/stream');
+        createEventSource.mockRestore();
+    });
+});

package/dist/api/files.test.js

@@ -27,7 +27,7 @@ describe('FilesAPI', () => {
                 upload_url: 'https://upload.example.com/put',
                 content_type: 'image/png',
             };
-            mockJsonResponse({ success: true, data: [fileRecord] });
+            mockJsonResponse([fileRecord]);
             mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
             const input = {
                 prompt: 'draw',
@@ -41,10 +41,7 @@ describe('FilesAPI', () => {
     });
     describe('upload', () => {
         it('should reject invalid data URI format when uploading content', async () => {
-            mockJsonResponse({
-                success: true,
-                data: [{ id: 'file-x', uri: '', upload_url: 'https://upload.example.com/put' }],
-            });
+            mockJsonResponse([{ id: 'file-x', uri: '', upload_url: 'https://upload.example.com/put' }]);
             await expect(api().upload('data:invalid')).rejects.toThrow('Invalid data URI format');
         });
         it('should decode URL-safe base64 in data URIs', async () => {
@@ -54,7 +51,7 @@ describe('FilesAPI', () => {
                 upload_url: 'https://upload.example.com/put',
                 content_type: 'text/plain',
             };
-            mockJsonResponse({ success: true, data: [fileRecord] });
+            mockJsonResponse([fileRecord]);
             mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
             // "SGVsbG8" is "Hello" in standard base64; URL-safe variant uses '-' instead of '+'
             const dataUri = 'data:text/plain;base64,SGVsbG8';

package/dist/api/flow-runs.test.d.ts

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

package/dist/api/flow-runs.test.js

@@ -0,0 +1,55 @@
+import { HttpClient } from '../http/client';
+import { FlowRunsAPI } from './flow-runs';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('FlowRunsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new FlowRunsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST flow and input for create()', async () => {
+        const flowRun = { id: 'fr-1', flow: 'flow-1' };
+        mockJsonResponse(flowRun);
+        const result = await api().create('flow-1', { prompt: 'hi' });
+        expect(result).toEqual(flowRun);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({
+            flow: 'flow-1',
+            input: { prompt: 'hi' },
+        });
+    });
+    it('should POST /flowruns/{id}/cancel for cancel()', async () => {
+        mockJsonResponse(null);
+        await api().cancel('fr-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flowruns/fr-1/cancel');
+        expect(init.method).toBe('POST');
+    });
+    it('should open SSE on /flowruns/{id}/stream for stream()', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const createEventSource = jest
+            .spyOn(http, 'createEventSource')
+            .mockResolvedValue(null);
+        const flowRuns = new FlowRunsAPI(http);
+        await flowRuns.stream('fr-42');
+        expect(createEventSource).toHaveBeenCalledWith('/flowruns/fr-42/stream');
+        createEventSource.mockRestore();
+    });
+    it('should open task SSE for streamTasks()', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const createEventSource = jest
+            .spyOn(http, 'createEventSource')
+            .mockResolvedValue(null);
+        const flowRuns = new FlowRunsAPI(http);
+        await flowRuns.streamTasks('fr-42');
+        expect(createEventSource).toHaveBeenCalledWith('/flowruns/fr-42/tasks/stream');
+        createEventSource.mockRestore();
+    });
+});

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

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

package/dist/api/flows.test.js

@@ -0,0 +1,43 @@
+import { HttpClient } from '../http/client';
+import { FlowsAPI } from './flows';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('FlowsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new FlowsAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST name for create()', async () => {
+        const flow = { id: 'flow-1', name: 'My Flow' };
+        mockJsonResponse(flow);
+        const result = await api().create('My Flow');
+        expect(result).toEqual(flow);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'My Flow' });
+    });
+    it('should POST /flows/{id}/app for createApp()', async () => {
+        const app = { id: 'app-from-flow' };
+        mockJsonResponse(app);
+        const result = await api().createApp('flow-1');
+        expect(result).toEqual(app);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/flows/flow-1/app');
+    });
+    it('should open SSE on /flows/{id}/stream for stream()', async () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        const createEventSource = jest
+            .spyOn(http, 'createEventSource')
+            .mockResolvedValue(null);
+        const flows = new FlowsAPI(http);
+        await flows.stream('flow-5');
+        expect(createEventSource).toHaveBeenCalledWith('/flows/flow-5/stream');
+        createEventSource.mockRestore();
+    });
+});

package/dist/api/sessions.d.ts

@@ -8,7 +8,8 @@ import { AppSessionDTO } from '../types';
  *
  * @example
  * ```typescript
- * const client = new Inference({ apiKey: '...' });
+ * import { inference } from '@inferencesh/sdk';
+ * const client = inference({ apiKey: '...' });
  *
  * // Get session info
  * const info = await client.sessions.get('sess_abc123');

package/dist/api/sessions.js

@@ -6,7 +6,8 @@
  *
  * @example
  * ```typescript
- * const client = new Inference({ apiKey: '...' });
+ * import { inference } from '@inferencesh/sdk';
+ * const client = inference({ apiKey: '...' });
  *
  * // Get session info
  * const info = await client.sessions.get('sess_abc123');

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

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

package/dist/api/sessions.test.js

@@ -0,0 +1,49 @@
+import { HttpClient } from '../http/client';
+import { SessionsAPI } from './sessions';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('SessionsAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    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(session);
+        const result = await api().get('sess_1');
+        expect(result).toEqual(session);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/sessions/sess_1');
+        expect(init.method).toBe('GET');
+    });
+    it('should return an empty array when list() response is null', async () => {
+        mockJsonResponse(null);
+        const result = await api().list();
+        expect(result).toEqual([]);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/sessions');
+    });
+    it('should POST /sessions/{id}/keepalive for keepalive()', async () => {
+        const session = { id: 'sess_2', status: 'active' };
+        mockJsonResponse(session);
+        const result = await api().keepalive('sess_2');
+        expect(result).toEqual(session);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/sessions/sess_2/keepalive');
+        expect(init.method).toBe('POST');
+    });
+    it('should DELETE /sessions/{id} for end()', async () => {
+        mockJsonResponse(null);
+        await api().end('sess_3');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/sessions/sess_3');
+        expect(init.method).toBe('DELETE');
+    });
+});

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,28 +47,42 @@ 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(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 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);
     });
@@ -97,7 +111,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);
@@ -114,7 +128,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));
@@ -142,6 +156,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({

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.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 = data.detail || data.title || data.message || 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.