@inferencesh/sdk 0.6.8 → 0.6.10

package/dist/http/client.test.js

@@ -1,7 +1,10 @@
 import { HttpClient, createHttpClient } from './client';
 import { InferenceError, RequirementsNotMetException } from './errors';
+import { EventSource } from 'eventsource';
+jest.mock('eventsource');
 const mockFetch = jest.fn();
 global.fetch = mockFetch;
+const MockEventSource = EventSource;
 function mockJsonResponse(body, status = 200, ok = true) {
     mockFetch.mockResolvedValueOnce({
         ok,
@@ -38,17 +41,12 @@ describe('HttpClient', () => {
     describe('request', () => {
         const client = () => new HttpClient({ apiKey: 'test-key' });
         it('should return parsed data on success', async () => {
-            mockJsonResponse({ success: true, data: { id: 'task-1' } });
+            mockJsonResponse({ id: 'task-1' });
             const result = await client().request('get', '/tasks/task-1');
             expect(result).toEqual({ id: 'task-1' });
         });
-        it('should return null when success is true but data field is omitted', async () => {
-            mockJsonResponse({ success: true });
-            const result = await client().request('post', '/tasks/task-1/cancel');
-            expect(result).toBeNull();
-        });
-        it('should return null when success is true with explicit data: null', async () => {
-            mockJsonResponse({ success: true, data: null });
+        it('should return null for null response body', async () => {
+            mockJsonResponse(null);
             const result = await client().request('post', '/tasks/task-1/cancel');
             expect(result).toBeNull();
         });
@@ -61,8 +59,8 @@ describe('HttpClient', () => {
             const result = await client().request('delete', '/tasks/task-1');
             expect(result).toBeUndefined();
         });
-        it('should throw InferenceError when success is false', async () => {
-            mockJsonResponse({ success: false, error: { message: 'Invalid request' } });
+        it('should throw InferenceError on non-ok response', async () => {
+            mockJsonResponse({ message: 'Invalid request' }, 400, false);
             const err = await client().request('get', '/tasks/1').catch((e) => e);
             expect(err).toBeInstanceOf(InferenceError);
             expect(err.message).toContain('Invalid request');
@@ -91,7 +89,7 @@ describe('HttpClient', () => {
                 .mockResolvedValueOnce({
                 ok: true,
                 status: 200,
-                text: () => Promise.resolve(JSON.stringify({ success: true, data: { ok: true } })),
+                text: () => Promise.resolve(JSON.stringify({ ok: true })),
             });
             const result = await httpClient.request('get', '/tasks/1');
             expect(result).toEqual({ ok: true });
@@ -99,7 +97,7 @@ describe('HttpClient', () => {
         });
         it('should route through proxy with x-inf-target-url header', async () => {
             const proxyClient = new HttpClient({ proxyUrl: 'https://proxy.example.com' });
-            mockJsonResponse({ success: true, data: { id: '1' } });
+            mockJsonResponse({ id: '1' });
             await proxyClient.request('get', '/tasks/1');
             expect(mockFetch).toHaveBeenCalledWith('https://proxy.example.com', expect.objectContaining({
                 headers: expect.objectContaining({
@@ -108,7 +106,7 @@ describe('HttpClient', () => {
             }));
         });
         it('should serialize array query params as JSON', async () => {
-            mockJsonResponse({ success: true, data: [] });
+            mockJsonResponse([]);
             await client().request('get', '/tasks', {
                 params: { ids: ['a', 'b'] },
             });
@@ -149,4 +147,44 @@ describe('HttpClient', () => {
             expect(config.headers.Authorization).toBe('Bearer dynamic-token');
         });
     });
+    describe('createEventSource', () => {
+        beforeEach(() => {
+            MockEventSource.mockReset();
+        });
+        it('should attach Bearer token in direct mode via 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' });
+            await client.createEventSource('/tasks/task-1/stream');
+            expect(capturedFetch).toBeDefined();
+            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 sse-key',
+                }),
+            }));
+        });
+        it('should route through proxy with target URL header on custom fetch', async () => {
+            let capturedFetch;
+            MockEventSource.mockImplementation((url, options) => {
+                capturedFetch = options?.fetch;
+                expect(url).toContain('https://proxy.example.com');
+                expect(url).toContain('__inf_target=');
+                return { close: jest.fn(), onmessage: null, onerror: null };
+            });
+            mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+            const client = new HttpClient({ proxyUrl: 'https://proxy.example.com' });
+            await client.createEventSource('/tasks/task-1/stream');
+            await capturedFetch('https://proxy.example.com', { headers: {} });
+            expect(mockFetch).toHaveBeenCalledWith('https://proxy.example.com', expect.objectContaining({
+                headers: expect.objectContaining({
+                    'x-inf-target-url': 'https://api.inference.sh/tasks/task-1/stream',
+                }),
+            }));
+        });
+    });
 });

package/dist/proxy/express.test.d.ts

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

package/dist/proxy/express.test.js

@@ -0,0 +1,106 @@
+import { INF_TARGET_HEADER } from './index';
+import { createHandler } from './express';
+function createMockResponse() {
+    const res = {
+        statusCode: 200,
+        headers: {},
+        body: undefined,
+        chunks: [],
+        status(code) {
+            this.statusCode = code;
+            return this;
+        },
+        setHeader(name, value) {
+            this.headers[name] = value;
+        },
+        json(data) {
+            this.body = data;
+            return this;
+        },
+        send(data) {
+            this.body = data;
+            return this;
+        },
+        write(chunk) {
+            this.chunks.push(chunk);
+        },
+        end() {
+            return;
+        },
+    };
+    return res;
+}
+describe('express createHandler', () => {
+    const originalFetch = global.fetch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.INFERENCE_API_KEY = 'express-test-key';
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+    it('should return 400 when target URL is missing', async () => {
+        const handler = createHandler();
+        const req = {
+            method: 'POST',
+            body: {},
+            headers: {},
+            query: {},
+        };
+        const res = createMockResponse();
+        await handler(req, res, jest.fn());
+        expect(res.statusCode).toBe(400);
+        expect(res.body).toEqual({
+            error: `Missing ${INF_TARGET_HEADER} header or __inf_target query param`,
+        });
+    });
+    it('should proxy JSON responses through res.json()', async () => {
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+        const handler = createHandler();
+        const target = 'https://api.inference.sh/v1/run';
+        const req = {
+            method: 'POST',
+            body: { prompt: 'hi' },
+            headers: { [INF_TARGET_HEADER]: target },
+            query: {},
+        };
+        const res = createMockResponse();
+        await handler(req, res, jest.fn());
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toEqual({ ok: true });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer express-test-key',
+            }),
+        }));
+    });
+    it('should stream SSE responses with res.write()', async () => {
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(encoder.encode('data: {"x":1}\n\n'));
+                controller.close();
+            },
+        });
+        global.fetch = jest.fn().mockResolvedValue(new Response(stream, {
+            status: 200,
+            headers: { 'content-type': 'text/event-stream' },
+        }));
+        const handler = createHandler();
+        const target = 'https://api.inference.sh/v1/stream';
+        const req = {
+            method: 'POST',
+            body: {},
+            headers: { [INF_TARGET_HEADER]: target },
+            query: {},
+        };
+        const res = createMockResponse();
+        await handler(req, res, jest.fn());
+        expect(res.statusCode).toBe(200);
+        expect(res.chunks.length).toBeGreaterThan(0);
+        expect(res.body).toBeUndefined();
+    });
+});

package/dist/proxy/index.test.js

@@ -1,4 +1,4 @@
-import { INF_TARGET_HEADER, INF_TARGET_PARAM, processProxyRequest, } from './index';
+import { INF_TARGET_HEADER, INF_TARGET_PARAM, headersToRecord, processProxyRequest, } from './index';
 function createTestAdapter(overrides = {}) {
     const state = { status: 0 };
     const adapter = {
@@ -26,6 +26,15 @@ function createTestAdapter(overrides = {}) {
     };
     return adapter;
 }
+describe('headersToRecord', () => {
+    it('should convert Headers to a plain record', () => {
+        const headers = new Headers({ 'x-test': 'value', 'content-type': 'application/json' });
+        expect(headersToRecord(headers)).toEqual({
+            'x-test': 'value',
+            'content-type': 'application/json',
+        });
+    });
+});
 describe('processProxyRequest', () => {
     const originalFetch = global.fetch;
     const originalApiKey = process.env.INFERENCE_API_KEY;