@inferencesh/sdk 0.6.4 → 0.6.6

package/dist/http/client.test.js

@@ -0,0 +1,152 @@
+import { HttpClient, createHttpClient } from './client';
+import { InferenceError, RequirementsNotMetException } from './errors';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body, status = 200, ok = true) {
+    mockFetch.mockResolvedValueOnce({
+        ok,
+        status,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('HttpClient', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('constructor', () => {
+        it('should throw when no apiKey, getToken, or proxyUrl', () => {
+            expect(() => new HttpClient({})).toThrow('Either apiKey, getToken, or proxyUrl is required');
+        });
+        it('should allow proxyUrl without apiKey', () => {
+            const client = new HttpClient({ proxyUrl: 'https://proxy.example.com' });
+            expect(client.isProxyMode()).toBe(true);
+        });
+        it('should expose stream and poll interval config', () => {
+            const client = new HttpClient({
+                apiKey: 'key',
+                stream: false,
+                pollIntervalMs: 5000,
+            });
+            expect(client.getStreamDefault()).toBe(false);
+            expect(client.getPollIntervalMs()).toBe(5000);
+        });
+        it('createHttpClient should return an HttpClient instance', () => {
+            const client = createHttpClient({ apiKey: 'key' });
+            expect(client).toBeInstanceOf(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' } });
+            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 });
+            const result = await client().request('post', '/tasks/task-1/cancel');
+            expect(result).toBeNull();
+        });
+        it('should return undefined for 204 No Content', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                status: 204,
+                text: () => Promise.resolve(''),
+            });
+            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' } });
+            const err = await client().request('get', '/tasks/1').catch((e) => e);
+            expect(err).toBeInstanceOf(InferenceError);
+            expect(err.message).toContain('Invalid request');
+        });
+        it('should throw RequirementsNotMetException on HTTP 412', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 412,
+                text: () => Promise.resolve(JSON.stringify({
+                    errors: [{ type: 'secret', key: 'API_KEY', message: 'Missing secret' }],
+                })),
+            });
+            await expect(client().request('post', '/apps/run')).rejects.toBeInstanceOf(RequirementsNotMetException);
+        });
+        it('should retry when onError handler calls retry', async () => {
+            const httpClient = new HttpClient({
+                apiKey: 'key',
+                onError: async (_error, retry) => retry(),
+            });
+            mockFetch
+                .mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                text: () => Promise.resolve('server error'),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify({ success: true, data: { ok: true } })),
+            });
+            const result = await httpClient.request('get', '/tasks/1');
+            expect(result).toEqual({ ok: true });
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+        });
+        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' } });
+            await proxyClient.request('get', '/tasks/1');
+            expect(mockFetch).toHaveBeenCalledWith('https://proxy.example.com', expect.objectContaining({
+                headers: expect.objectContaining({
+                    'x-inf-target-url': 'https://api.inference.sh/tasks/1',
+                }),
+            }));
+        });
+        it('should serialize array query params as JSON', async () => {
+            mockJsonResponse({ success: true, data: [] });
+            await client().request('get', '/tasks', {
+                params: { ids: ['a', 'b'] },
+            });
+            const calledUrl = mockFetch.mock.calls[0][0];
+            expect(calledUrl).toContain('ids=');
+            expect(decodeURIComponent(calledUrl)).toContain('["a","b"]');
+        });
+        it('should use top-level message field in HTTP error responses', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 503,
+                text: () => Promise.resolve(JSON.stringify({ message: 'service unavailable' })),
+            });
+            await expect(client().request('get', '/tasks/1')).rejects.toMatchObject({
+                name: 'InferenceError',
+                message: expect.stringContaining('service unavailable'),
+            });
+        });
+    });
+    describe('getStreamableConfig', () => {
+        it('should include bearer token in direct mode', () => {
+            const config = new HttpClient({ apiKey: 'secret-key' }).getStreamableConfig('/tasks/task-1/stream');
+            expect(config.url).toBe('https://api.inference.sh/tasks/task-1/stream');
+            expect(config.headers.Authorization).toBe('Bearer secret-key');
+        });
+        it('should route through proxy with target URL header', () => {
+            const config = new HttpClient({
+                proxyUrl: 'https://proxy.example.com/api',
+            }).getStreamableConfig('/tasks/task-1/stream');
+            expect(config.url).toContain('https://proxy.example.com/api');
+            expect(config.url).toContain('__inf_target=');
+            expect(config.headers['x-inf-target-url']).toBe('https://api.inference.sh/tasks/task-1/stream');
+        });
+        it('should use getToken when apiKey is not set', () => {
+            const config = new HttpClient({
+                getToken: () => 'dynamic-token',
+            }).getStreamableConfig('/tasks/task-1/stream');
+            expect(config.headers.Authorization).toBe('Bearer dynamic-token');
+        });
+    });
+});

package/dist/http/errors.test.d.ts

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

package/dist/http/errors.test.js

@@ -0,0 +1,53 @@
+import { InferenceError, RequirementsNotMetException, SessionEndedError, SessionExpiredError, SessionNotFoundError, WorkerLostError, isInferenceError, isRequirementsNotMetException, isSessionError, } from './errors';
+describe('error type guards', () => {
+    it('isRequirementsNotMetException should match instances and plain objects', () => {
+        const instance = new RequirementsNotMetException([
+            { type: 'secret', key: 'K', message: 'missing' },
+        ]);
+        expect(isRequirementsNotMetException(instance)).toBe(true);
+        const plain = {
+            name: 'RequirementsNotMetException',
+            statusCode: 412,
+            errors: [{ type: 'secret', key: 'K', message: 'missing' }],
+        };
+        expect(isRequirementsNotMetException(plain)).toBe(true);
+        expect(isRequirementsNotMetException(new Error('other'))).toBe(false);
+    });
+    it('isInferenceError should match instances and plain objects', () => {
+        const instance = new InferenceError(500, 'server error');
+        expect(isInferenceError(instance)).toBe(true);
+        expect(isInferenceError({ name: 'InferenceError', statusCode: 404 })).toBe(true);
+        expect(isInferenceError({ name: 'InferenceError' })).toBe(false);
+    });
+    it('isSessionError should match session error subclasses and plain objects', () => {
+        const instance = new SessionNotFoundError('sess-1');
+        expect(isSessionError(instance)).toBe(true);
+        expect(isSessionError({
+            name: 'SessionNotFoundError',
+            sessionId: 'sess-1',
+            statusCode: 404,
+        })).toBe(true);
+        expect(isSessionError({ name: 'InferenceError', statusCode: 500 })).toBe(false);
+    });
+    it('session error subclasses should expose sessionId', () => {
+        expect(new SessionNotFoundError('sess-1').sessionId).toBe('sess-1');
+        expect(new SessionExpiredError('sess-2').statusCode).toBe(410);
+        expect(new SessionEndedError('sess-3').name).toBe('SessionEndedError');
+        expect(new WorkerLostError('sess-4').statusCode).toBe(500);
+    });
+});
+describe('error classes', () => {
+    it('RequirementsNotMetException.fromResponse should default empty errors', () => {
+        const err = RequirementsNotMetException.fromResponse({}, 412);
+        expect(err.errors).toEqual([]);
+        expect(err.statusCode).toBe(412);
+        expect(err.message).toBe('requirements not met');
+    });
+    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);
+        expect(new SessionExpiredError('sess-b').statusCode).toBe(410);
+        expect(new SessionEndedError('sess-c').message).toContain('sess-c');
+        expect(new WorkerLostError('sess-d').name).toBe('WorkerLostError');
+    });
+});

package/dist/http/poll.test.d.ts

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

package/dist/http/poll.test.js

@@ -0,0 +1,85 @@
+import { PollManager } from './poll';
+describe('PollManager', () => {
+    beforeEach(() => {
+        jest.useFakeTimers();
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    it('should invoke onData after the immediate first poll', async () => {
+        const onData = jest.fn();
+        const pollFunction = jest.fn().mockResolvedValue({ status: 'running' });
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 1000,
+            onData,
+        });
+        manager.start();
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(1);
+        expect(onData).toHaveBeenCalledWith({ status: 'running' });
+        manager.stop();
+    });
+    it('should poll repeatedly at intervalMs', async () => {
+        const pollFunction = jest.fn().mockResolvedValue({ status: 'running' });
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 1000,
+        });
+        manager.start();
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(1);
+        jest.advanceTimersByTime(1000);
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(2);
+        manager.stop();
+    });
+    it('should call onStart when started and onStop when stopped', async () => {
+        const onStart = jest.fn();
+        const onStop = jest.fn();
+        const pollFunction = jest.fn().mockResolvedValue({});
+        const manager = new PollManager({ pollFunction, onStart, onStop });
+        manager.start();
+        expect(onStart).toHaveBeenCalled();
+        manager.stop();
+        expect(onStop).toHaveBeenCalled();
+    });
+    it('should stop after maxRetries consecutive poll errors', async () => {
+        const onError = jest.fn();
+        const onStop = jest.fn();
+        const pollFunction = jest.fn().mockRejectedValue(new Error('network error'));
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 100,
+            maxRetries: 3,
+            onError,
+            onStop,
+        });
+        manager.start();
+        // Immediate first poll
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(onError).toHaveBeenCalledTimes(3);
+        expect(onStop).toHaveBeenCalled();
+        expect(pollFunction.mock.calls.length).toBeGreaterThanOrEqual(3);
+    });
+    it('should not invoke onData after stop', async () => {
+        const onData = jest.fn();
+        const pollFunction = jest.fn().mockResolvedValue({ status: 'running' });
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 100,
+            onData,
+        });
+        manager.start();
+        await Promise.resolve();
+        manager.stop();
+        const callsBefore = onData.mock.calls.length;
+        jest.advanceTimersByTime(500);
+        await Promise.resolve();
+        expect(onData.mock.calls.length).toBe(callsBefore);
+    });
+});

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

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

package/dist/proxy/index.test.js

@@ -0,0 +1,147 @@
+import { INF_TARGET_HEADER, INF_TARGET_PARAM, processProxyRequest, } from './index';
+function createTestAdapter(overrides = {}) {
+    const state = { status: 0 };
+    const adapter = {
+        framework: 'test',
+        method: 'POST',
+        body: async () => '{"ok":true}',
+        headers: () => ({}),
+        header: () => undefined,
+        query: () => undefined,
+        setHeader: (name, value) => {
+            state.headers = state.headers ?? {};
+            state.headers[name] = value;
+        },
+        error: (status, message) => {
+            state.status = status;
+            state.body = message;
+            return state;
+        },
+        respond: async (response) => {
+            state.status = response.status;
+            state.body = await response.text();
+            return state;
+        },
+        ...overrides,
+    };
+    return adapter;
+}
+describe('processProxyRequest', () => {
+    const originalFetch = global.fetch;
+    const originalApiKey = process.env.INFERENCE_API_KEY;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.INFERENCE_API_KEY = 'env-test-key';
+        global.fetch = jest.fn().mockResolvedValue(new Response(JSON.stringify({ ok: true }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+        }));
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+        if (originalApiKey === undefined) {
+            delete process.env.INFERENCE_API_KEY;
+        }
+        else {
+            process.env.INFERENCE_API_KEY = originalApiKey;
+        }
+    });
+    it('should reject requests without a target URL', async () => {
+        const result = await processProxyRequest(createTestAdapter());
+        expect(result.status).toBe(400);
+        expect(result.body).toEqual({
+            error: `Missing ${INF_TARGET_HEADER} header or ${INF_TARGET_PARAM} query param`,
+        });
+        expect(global.fetch).not.toHaveBeenCalled();
+    });
+    it('should reject invalid target URLs', async () => {
+        const result = await processProxyRequest(createTestAdapter({
+            header: (name) => (name === INF_TARGET_HEADER ? 'not-a-url' : undefined),
+        }));
+        expect(result.status).toBe(400);
+        expect(result.body).toEqual({ error: 'Invalid target URL' });
+        expect(global.fetch).not.toHaveBeenCalled();
+    });
+    it('should reject non-inference.sh domains', async () => {
+        const result = await processProxyRequest(createTestAdapter({
+            header: (name) => name === INF_TARGET_HEADER ? 'https://evil.example.com/run' : undefined,
+        }));
+        expect(result.status).toBe(412);
+        expect(result.body).toEqual({
+            error: 'Target must be an inference.sh domain, got: evil.example.com',
+        });
+        expect(global.fetch).not.toHaveBeenCalled();
+    });
+    it('should reject when no API key is configured', async () => {
+        delete process.env.INFERENCE_API_KEY;
+        const result = await processProxyRequest(createTestAdapter({
+            header: (name) => name === INF_TARGET_HEADER ? 'https://api.inference.sh/run' : undefined,
+        }));
+        expect(result.status).toBe(401);
+        expect(result.body).toEqual({
+            error: 'Missing INFERENCE_API_KEY environment variable',
+        });
+        expect(global.fetch).not.toHaveBeenCalled();
+    });
+    it('should proxy valid inference.sh requests with env API key', async () => {
+        const target = 'https://api.inference.sh/v1/tasks/1';
+        const result = await processProxyRequest(createTestAdapter({
+            header: (name) => (name === INF_TARGET_HEADER ? target : undefined),
+        }));
+        expect(result.status).toBe(200);
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({
+                authorization: 'Bearer env-test-key',
+                'x-inf-proxy': '@inferencesh/sdk-proxy/test',
+            }),
+        }));
+    });
+    it('should use query param fallback when header is missing (SSE clients)', async () => {
+        const target = 'https://api.inference.sh/v1/stream';
+        const encoded = encodeURIComponent(target);
+        await processProxyRequest(createTestAdapter({
+            query: (name) => (name === INF_TARGET_PARAM ? encoded : undefined),
+        }));
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.any(Object));
+    });
+    it('should honor custom allowedDomains', async () => {
+        const target = 'https://cdn.custom.example/upload';
+        await processProxyRequest(createTestAdapter({
+            header: (name) => (name === INF_TARGET_HEADER ? target : undefined),
+        }), { apiKey: 'custom-key', allowedDomains: [/custom\.example$/] });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.any(Object));
+    });
+    it('should forward x-inf-* request headers to upstream', async () => {
+        const target = 'https://api.inference.sh/run';
+        await processProxyRequest(createTestAdapter({
+            header: (name) => {
+                if (name === INF_TARGET_HEADER)
+                    return target;
+                if (name === 'x-inf-session-id')
+                    return 'sess-123';
+                return undefined;
+            },
+            headers: () => ({
+                [INF_TARGET_HEADER]: target,
+                'x-inf-session-id': 'sess-123',
+            }),
+        }), { apiKey: 'key' });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                'x-inf-session-id': 'sess-123',
+            }),
+        }));
+    });
+    it('should omit body for GET requests', async () => {
+        const target = 'https://api.inference.sh/tasks/1';
+        await processProxyRequest(createTestAdapter({
+            method: 'GET',
+            header: (name) => (name === INF_TARGET_HEADER ? target : undefined),
+        }), { apiKey: 'key' });
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            method: 'GET',
+            body: undefined,
+        }));
+    });
+});

package/dist/stream.test.js

@@ -128,6 +128,54 @@ describe('StreamManager', () => {
             expect(onData).not.toHaveBeenCalled();
         });
     });
+    describe('addEventListener', () => {
+        it('should deliver typed SSE events to registered listeners', async () => {
+            const typedListeners = {};
+            const eventSource = {
+                onmessage: null,
+                onerror: null,
+                close: jest.fn(),
+                addEventListener: (eventName, handler) => {
+                    const listeners = typedListeners[eventName] || new Set();
+                    listeners.add(handler);
+                    typedListeners[eventName] = listeners;
+                },
+            };
+            const manager = new StreamManager({
+                createEventSource: async () => eventSource,
+            });
+            const onChat = jest.fn();
+            manager.addEventListener('chats', onChat);
+            await manager.connect();
+            const payload = { id: 'chat-1', status: 'open' };
+            typedListeners.chats?.forEach((handler) => handler({ data: JSON.stringify(payload) }));
+            expect(onChat).toHaveBeenCalledWith(payload);
+        });
+        it('should unwrap partial wrappers for typed events', async () => {
+            const typedListeners = {};
+            const eventSource = {
+                onmessage: null,
+                onerror: null,
+                close: jest.fn(),
+                addEventListener: (eventName, handler) => {
+                    const listeners = typedListeners[eventName] || new Set();
+                    listeners.add(handler);
+                    typedListeners[eventName] = listeners;
+                },
+            };
+            const manager = new StreamManager({
+                createEventSource: async () => eventSource,
+            });
+            const onMessage = jest.fn();
+            manager.addEventListener('chat_messages', onMessage);
+            await manager.connect();
+            const inner = { id: 'msg-1', order: 1 };
+            typedListeners.chat_messages?.forEach((handler) => handler({
+                data: JSON.stringify({ data: inner, fields: ['order'] }),
+            }));
+            expect(onMessage).toHaveBeenCalledWith(inner);
+        });
+    });
     describe('reconnection', () => {
         it('should attempt reconnection on error when autoReconnect is true', async () => {
             jest.useFakeTimers();