@inferencesh/sdk 0.6.10 → 0.6.13

package/dist/api/teams.test.js

@@ -0,0 +1,139 @@
+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);
+    });
+    it('should GET /teams/{id} for get()', async () => {
+        const team = { id: 'team-1', name: 'Acme' };
+        mockJsonResponse(team);
+        const result = await api().get('team-1');
+        expect(result).toEqual(team);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /teams/{id} for update()', async () => {
+        const team = { id: 'team-1', name: 'Acme Updated' };
+        mockJsonResponse(team);
+        const result = await api().update('team-1', { name: 'Acme Updated' });
+        expect(result).toEqual(team);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1');
+        expect(JSON.parse(init.body)).toEqual({ name: 'Acme Updated' });
+    });
+    it('should DELETE /teams/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('team-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should GET /teams/{id}/members for getMembers()', async () => {
+        const members = [{ user_id: 'user-1', role: 'owner' }];
+        mockJsonResponse(members);
+        const result = await api().getMembers('team-1');
+        expect(result).toEqual(members);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1/members');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /teams/{id}/members for addMember()', async () => {
+        const payload = { user_id: 'user-4', role: 'member' };
+        const member = { ...payload };
+        mockJsonResponse(member);
+        const result = await api().addMember('team-1', payload);
+        expect(result).toEqual(member);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1/members');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+    it('should GET /teams/{id}/invites for listInvites()', async () => {
+        const invites = [{ id: 'inv-1', email: 'dev@example.com' }];
+        mockJsonResponse(invites);
+        const result = await api().listInvites('team-1');
+        expect(result).toEqual(invites);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1/invites');
+        expect(init.method).toBe('GET');
+    });
+    it('should DELETE /teams/{id}/invites/{inviteId} for revokeInvite()', async () => {
+        mockJsonResponse(null);
+        await api().revokeInvite('team-1', 'inv-9');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/teams/team-1/invites/inv-9');
+        expect(init.method).toBe('DELETE');
+    });
+});

package/dist/client.test.js

@@ -1,5 +1,7 @@
-import { Inference, inference } from './index';
+import { Inference, inference, createClient } from './index';
 import { RequirementsNotMetException } from './http/errors';
+import { HttpClient } from './http/client';
+import { ChatStatusBusy, ChatStatusIdle } from './types';
 // Mock fetch globally
 const mockFetch = jest.fn();
 global.fetch = mockFetch;
@@ -138,6 +140,45 @@ describe('Inference', () => {
                 expect(exception.errors[0].action?.scopes).toEqual(['calendar.readonly', 'calendar.events']);
             }
         });
+        it('should process Blob inputs via processInput before calling /apps/run', async () => {
+            const fileRecord = {
+                id: 'file-blob',
+                uri: 'inf://files/blob',
+                upload_url: 'https://upload.example.com/put',
+                content_type: 'image/png',
+            };
+            const mockTask = {
+                id: 'task-456',
+                status: 9,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+                input: {},
+                output: { result: 'done' },
+            };
+            mockFetch
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify([fileRecord])),
+                json: () => Promise.resolve([fileRecord]),
+            })
+                .mockResolvedValueOnce({ ok: true, status: 200 })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(mockTask)),
+                json: () => Promise.resolve(mockTask),
+            });
+            const client = new Inference({ apiKey: 'test-api-key' });
+            const blob = new Blob(['png-bytes'], { type: 'image/png' });
+            const result = await client.run({ app: 'test-app', input: { image: blob } }, { wait: false });
+            expect(result.id).toBe('task-456');
+            expect(mockFetch).toHaveBeenCalledTimes(3);
+            const runCall = mockFetch.mock.calls.find((call) => String(call[0]).includes('/apps/run'));
+            expect(runCall).toBeDefined();
+            const runBody = JSON.parse(runCall[1].body);
+            expect(runBody.input.image).toBe('inf://files/blob');
+        });
     });
     describe('cancel', () => {
         it('should make a POST request to cancel endpoint', async () => {
@@ -153,6 +194,76 @@ describe('Inference', () => {
             expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/tasks/task-123/cancel'), expect.objectContaining({ method: 'POST' }));
         });
     });
+    describe('legacy task helpers', () => {
+        it('should delegate getTask() to tasks.get', async () => {
+            const mockTask = { id: 'task-legacy', status: 9 };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(mockTask)),
+                json: () => Promise.resolve(mockTask),
+            });
+            const client = new Inference({ apiKey: 'test-api-key' });
+            const result = await client.getTask('task-legacy');
+            expect(result.id).toBe('task-legacy');
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/tasks/task-legacy'), expect.objectContaining({ method: 'GET' }));
+        });
+        it('should delegate streamTask() to tasks.stream', async () => {
+            const client = new Inference({ apiKey: 'test-api-key' });
+            const createEventSource = jest
+                .spyOn(HttpClient.prototype, 'createEventSource')
+                .mockResolvedValue(null);
+            await client.streamTask('task-stream');
+            expect(createEventSource).toHaveBeenCalledWith('/tasks/task-stream/stream');
+            createEventSource.mockRestore();
+        });
+    });
+    describe('agent()', () => {
+        it('should return an Agent whose sendMessage hits POST /agents/run', async () => {
+            mockFetch
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({
+                    user_message: { id: 'user-1', chat_id: 'chat-1', role: 'user', content: 'hi' },
+                    assistant_message: { id: 'asst-1', chat_id: 'chat-1', role: 'assistant', content: 'hello' },
+                })),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({ status: ChatStatusBusy })),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({ id: 'chat-1', status: ChatStatusBusy, chat_messages: [] })),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({ status: ChatStatusIdle })),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({ id: 'chat-1', status: ChatStatusIdle, chat_messages: [] })),
+            });
+            const client = new Inference({ apiKey: 'test-api-key', stream: false, pollIntervalMs: 20 });
+            const agentInstance = client.agent('my-agent');
+            await agentInstance.sendMessage('hi', { stream: false });
+            const runCall = mockFetch.mock.calls.find(([url]) => String(url).includes('/agents/run'));
+            expect(runCall).toBeDefined();
+            const body = JSON.parse(runCall[1].body);
+            expect(body.agent).toBe('my-agent');
+        });
+    });
+    describe('createClient', () => {
+        it('should create an Inference instance with extended HttpClient config', () => {
+            const client = createClient({ apiKey: 'extended-key', baseUrl: 'https://api.example.com' });
+            expect(client).toBeInstanceOf(Inference);
+        });
+    });
     describe('lowercase factory', () => {
         it('should export lowercase inference factory', () => {
             expect(typeof inference).toBe('function');

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

@@ -128,7 +128,7 @@ export class HttpClient {
             }
             let errorDetail;
             if (data && typeof data === 'object') {
-                errorDetail = data.detail || data.title || data.message || JSON.stringify(data);
+                errorDetail = this.extractErrorDetail(data) ?? JSON.stringify(data);
             }
             else if (responseText) {
                 errorDetail = responseText.slice(0, 500);
@@ -164,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
@@ -183,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 }));
     }
 }
 /**

package/dist/http/client.test.js

@@ -114,6 +114,32 @@ describe('HttpClient', () => {
             expect(calledUrl).toContain('ids=');
             expect(decodeURIComponent(calledUrl)).toContain('["a","b"]');
         });
+        it('should serialize object query params as JSON', async () => {
+            mockJsonResponse([]);
+            await client().request('get', '/tasks', {
+                params: { filter: { status: 'active', team_id: 'team-1' } },
+            });
+            const calledUrl = mockFetch.mock.calls[0][0];
+            expect(calledUrl).toContain('filter=');
+            expect(decodeURIComponent(calledUrl)).toContain('"status":"active"');
+            expect(decodeURIComponent(calledUrl)).toContain('"team_id":"team-1"');
+        });
+        it('should omit Authorization when getToken returns null', async () => {
+            mockJsonResponse({ id: 'task-1' });
+            const tokenClient = new HttpClient({ getToken: () => null });
+            await tokenClient.request('get', '/tasks/task-1');
+            const [, init] = mockFetch.mock.calls[0];
+            const headers = init.headers;
+            expect(headers.Authorization).toBeUndefined();
+        });
+        it('should omit Authorization when getToken returns undefined', async () => {
+            mockJsonResponse({ id: 'task-1' });
+            const tokenClient = new HttpClient({ getToken: () => undefined });
+            await tokenClient.request('get', '/tasks/task-1');
+            const [, init] = mockFetch.mock.calls[0];
+            const headers = init.headers;
+            expect(headers.Authorization).toBeUndefined();
+        });
         it('should use top-level message field in HTTP error responses', async () => {
             mockFetch.mockResolvedValueOnce({
                 ok: false,
@@ -125,6 +151,99 @@ describe('HttpClient', () => {
                 message: expect.stringContaining('service unavailable'),
             });
         });
+        it('should use getToken for Authorization on regular requests', async () => {
+            mockJsonResponse({ id: 'task-1' });
+            const tokenClient = new HttpClient({ getToken: () => 'dynamic-key' });
+            await tokenClient.request('get', '/tasks/task-1');
+            const [, init] = mockFetch.mock.calls[0];
+            const headers = init.headers;
+            expect(headers.Authorization).toBe('Bearer dynamic-key');
+        });
+        it('should resolve function-valued headers on each request', async () => {
+            mockJsonResponse({ id: 'task-1' });
+            mockJsonResponse({ id: 'task-2' });
+            let teamId = 'team-a';
+            const client = new HttpClient({
+                apiKey: 'test-key',
+                headers: {
+                    'X-Team-ID': () => teamId,
+                    'X-Request-Id': () => 'req-1',
+                },
+            });
+            await client.request('get', '/tasks/task-1');
+            teamId = 'team-b';
+            await client.request('get', '/tasks/task-2');
+            const firstHeaders = mockFetch.mock.calls[0][1]?.headers;
+            const secondHeaders = mockFetch.mock.calls[1][1]?.headers;
+            expect(firstHeaders['X-Team-ID']).toBe('team-a');
+            expect(secondHeaders['X-Team-ID']).toBe('team-b');
+            expect(firstHeaders['X-Request-Id']).toBe('req-1');
+        });
+        it('should omit headers when a resolver returns undefined', async () => {
+            mockJsonResponse({ id: 'task-1' });
+            const client = new HttpClient({
+                apiKey: 'test-key',
+                headers: {
+                    'X-Team-ID': () => undefined,
+                    'X-Custom': 'static',
+                },
+            });
+            await client.request('get', '/tasks/task-1');
+            const headers = mockFetch.mock.calls[0][1]?.headers;
+            expect(headers['X-Team-ID']).toBeUndefined();
+            expect(headers['X-Custom']).toBe('static');
+        });
+        it('should send X-API-Version 2 and X-Client-Source on every request', async () => {
+            mockJsonResponse({ id: 'task-1' });
+            await client().request('get', '/tasks/task-1');
+            const [, init] = mockFetch.mock.calls[0];
+            const headers = init.headers;
+            expect(headers['X-API-Version']).toBe('2');
+            expect(headers['X-Client-Source']).toMatch(/inference-sdk-js\//);
+        });
+        it('should prefer RFC 9457 detail over title in error responses', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 422,
+                text: () => Promise.resolve(JSON.stringify({
+                    type: 'about:blank',
+                    title: 'Validation failed',
+                    detail: 'app field is required',
+                })),
+            });
+            await expect(client().request('post', '/apps')).rejects.toMatchObject({
+                name: 'InferenceError',
+                message: expect.stringContaining('app field is required'),
+            });
+        });
+        it('should fall back to RFC 9457 title when detail is absent', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 403,
+                text: () => Promise.resolve(JSON.stringify({ type: 'about:blank', title: 'Forbidden' })),
+            });
+            await expect(client().request('get', '/tasks/1')).rejects.toMatchObject({
+                name: 'InferenceError',
+                message: expect.stringContaining('Forbidden'),
+            });
+        });
+        it('should use raw response text when error body is not JSON', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 502,
+                text: () => Promise.resolve('Bad Gateway from upstream'),
+            });
+            await expect(client().request('get', '/tasks/1')).rejects.toMatchObject({
+                name: 'InferenceError',
+                message: expect.stringContaining('Bad Gateway from upstream'),
+            });
+        });
+        it('should not unwrap legacy v1 APIResponse envelopes', async () => {
+            const v1Envelope = { success: true, data: { id: 'task-legacy' } };
+            mockJsonResponse(v1Envelope);
+            const result = await client().request('get', '/tasks/legacy');
+            expect(result).toEqual(v1Envelope);
+        });
     });
     describe('getStreamableConfig', () => {
         it('should include bearer token in direct mode', () => {
@@ -146,6 +265,14 @@ describe('HttpClient', () => {
             }).getStreamableConfig('/tasks/task-1/stream');
             expect(config.headers.Authorization).toBe('Bearer dynamic-token');
         });
+        it('should include resolved dynamic headers for streaming requests', () => {
+            const config = new HttpClient({
+                apiKey: 'secret-key',
+                headers: { 'X-Team-ID': () => 'team-stream' },
+            }).getStreamableConfig('/tasks/task-1/stream');
+            expect(config.headers['X-Team-ID']).toBe('team-stream');
+            expect(config.headers.Authorization).toBe('Bearer secret-key');
+        });
     });
     describe('createEventSource', () => {
         beforeEach(() => {
@@ -186,5 +313,123 @@ describe('HttpClient', () => {
                 }),
             }));
         });
+        it('should attach resolved dynamic headers on SSE custom fetch', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const client = new HttpClient({
+                apiKey: 'sse-key',
+                headers: { 'X-Team-ID': () => 'team-sse' },
+            });
+            await client.createEventSource('/tasks/task-1/stream');
+            await capturedFetch('https://api.inference.sh/tasks/task-1/stream', { headers: {} });
+            expect(mockFetch).toHaveBeenCalledWith('https://api.inference.sh/tasks/task-1/stream', expect.objectContaining({
+                headers: expect.objectContaining({
+                    'X-Team-ID': 'team-sse',
+                    Authorization: 'Bearer sse-key',
+                }),
+            }));
+        });
+        it('should use getToken for Authorization on SSE custom fetch', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const client = new HttpClient({ getToken: () => 'session-token' });
+            await client.createEventSource('/tasks/task-1/stream');
+            await capturedFetch('https://api.inference.sh/tasks/task-1/stream', { headers: {} });
+            expect(mockFetch).toHaveBeenCalledWith('https://api.inference.sh/tasks/task-1/stream', expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer session-token',
+                }),
+            }));
+        });
+        it('should omit Authorization on SSE fetch when getToken returns null', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const client = new HttpClient({ getToken: () => null });
+            await client.createEventSource('/tasks/task-1/stream');
+            await capturedFetch('https://api.inference.sh/tasks/task-1/stream', { headers: {} });
+            const [, init] = mockFetch.mock.calls[0];
+            const headers = init.headers;
+            expect(headers.Authorization).toBeUndefined();
+        });
+        it('should return EventSource without awaiting the initial fetch', async () => {
+            MockEventSource.mockImplementation(() => ({ close: jest.fn() }));
+            const client = new HttpClient({ apiKey: 'sse-key' });
+            const eventSource = await client.createEventSource('/tasks/task-1/stream');
+            expect(eventSource).toBeDefined();
+            expect(MockEventSource).toHaveBeenCalled();
+            expect(mockFetch).not.toHaveBeenCalled();
+        });
+        function mockFailedResponse(status, body) {
+            return {
+                ok: false,
+                status,
+                clone: () => ({
+                    text: () => Promise.resolve(body),
+                }),
+            };
+        }
+        it('should route failed initial SSE response through onError and return retried response', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            const onError = jest.fn(async (_error, retry) => retry());
+            const client = new HttpClient({ apiKey: 'sse-key', onError });
+            mockFetch
+                .mockResolvedValueOnce(mockFailedResponse(403, JSON.stringify({ detail: 'otp_required' })))
+                .mockResolvedValueOnce({ ok: true, status: 200 });
+            await client.createEventSource('/tasks/task-1/stream');
+            const response = await capturedFetch('https://api.inference.sh/tasks/task-1/stream', {});
+            expect(onError).toHaveBeenCalledTimes(1);
+            const [error] = onError.mock.calls[0];
+            expect(error).toBeInstanceOf(InferenceError);
+            expect(error.statusCode).toBe(403);
+            expect(error.message).toContain('otp_required');
+            expect(response).toEqual({ ok: true, status: 200 });
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+        });
+        it('should return original failed response when onError does not retry', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            const failed = mockFailedResponse(401, JSON.stringify({ title: 'Unauthorized' }));
+            const onError = jest.fn(async () => undefined);
+            const client = new HttpClient({ apiKey: 'sse-key', onError });
+            mockFetch.mockResolvedValueOnce(failed);
+            await client.createEventSource('/tasks/task-1/stream');
+            const response = await capturedFetch('https://api.inference.sh/tasks/task-1/stream', {});
+            expect(onError).toHaveBeenCalledTimes(1);
+            expect(response).toBe(failed);
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+        });
+        it('should return failed response when no onError handler is configured', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((_url, options) => {
+                capturedFetch = options?.fetch;
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            const failed = mockFailedResponse(503, 'service unavailable');
+            const client = new HttpClient({ apiKey: 'sse-key' });
+            mockFetch.mockResolvedValueOnce(failed);
+            await client.createEventSource('/tasks/task-1/stream');
+            const response = await capturedFetch('https://api.inference.sh/tasks/task-1/stream', {});
+            expect(response).toBe(failed);
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+        });
     });
 });

package/dist/http/errors.test.js

@@ -1,4 +1,5 @@
 import { InferenceError, RequirementsNotMetException, SessionEndedError, SessionExpiredError, SessionNotFoundError, WorkerLostError, isInferenceError, isRequirementsNotMetException, isSessionError, } from './errors';
+import { RequirementTypeIntegration, RequirementTypeScope, RequirementTypeSecret, } from '../types';
 describe('error type guards', () => {
     it('isRequirementsNotMetException should match instances and plain objects', () => {
         const instance = new RequirementsNotMetException([
@@ -43,6 +44,18 @@ describe('error classes', () => {
         expect(err.statusCode).toBe(412);
         expect(err.message).toBe('requirements not met');
     });
+    it('RequirementsNotMetException should preserve typed RequirementType values', () => {
+        const errors = [
+            { type: RequirementTypeSecret, key: 'API_KEY', message: 'Missing secret' },
+            { type: RequirementTypeIntegration, key: 'google', message: 'Not connected' },
+            { type: RequirementTypeScope, key: 'calendar.readonly', message: 'Missing scope' },
+        ];
+        const err = new RequirementsNotMetException(errors);
+        expect(err.errors[0].type).toBe('secret');
+        expect(err.errors[1].type).toBe('integration');
+        expect(err.errors[2].type).toBe('scope');
+        expect(isRequirementsNotMetException(err)).toBe(true);
+    });
     it('session error subclasses should expose sessionId and statusCode', () => {
         expect(new SessionNotFoundError('sess-a').sessionId).toBe('sess-a');
         expect(new SessionNotFoundError('sess-a').statusCode).toBe(404);