@inferencesh/sdk 0.6.15 → 0.6.20

package/dist/http/client.test.js

@@ -1,435 +0,0 @@
-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,
-        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({ id: 'task-1' });
-            const result = await client().request('get', '/tasks/task-1');
-            expect(result).toEqual({ id: 'task-1' });
-        });
-        it('should return null for null response body', async () => {
-            mockJsonResponse(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 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');
-        });
-        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({ 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({ 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([]);
-            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 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,
-                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'),
-            });
-        });
-        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', () => {
-            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');
-        });
-        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(() => {
-            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',
-                }),
-            }));
-        });
-        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.d.ts

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

package/dist/http/errors.test.js

@@ -1,66 +0,0 @@
-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([
-            { 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('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);
-        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

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

package/dist/http/poll.test.js

@@ -1,146 +0,0 @@
-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);
-    });
-    it('should not run overlapping polls when pollFunction is still in flight', async () => {
-        let resolvePoll = () => { };
-        const pollFunction = jest.fn().mockImplementation(() => new Promise((resolve) => {
-            resolvePoll = resolve;
-        }));
-        const manager = new PollManager({
-            pollFunction,
-            intervalMs: 100,
-        });
-        manager.start();
-        await Promise.resolve();
-        expect(pollFunction).toHaveBeenCalledTimes(1);
-        jest.advanceTimersByTime(100);
-        await Promise.resolve();
-        expect(pollFunction).toHaveBeenCalledTimes(1);
-        resolvePoll({ status: 'ok' });
-        await Promise.resolve();
-        jest.advanceTimersByTime(100);
-        await Promise.resolve();
-        expect(pollFunction).toHaveBeenCalledTimes(2);
-        manager.stop();
-    });
-    it('should ignore start() when polling is already active', async () => {
-        const onStart = jest.fn();
-        const pollFunction = jest.fn().mockResolvedValue({});
-        const manager = new PollManager({ pollFunction, onStart });
-        manager.start();
-        manager.start();
-        expect(onStart).toHaveBeenCalledTimes(1);
-        manager.stop();
-    });
-    it('should reset consecutive error count after a successful poll', async () => {
-        const onError = jest.fn();
-        const onStop = jest.fn();
-        const pollFunction = jest
-            .fn()
-            .mockRejectedValueOnce(new Error('fail 1'))
-            .mockResolvedValueOnce({ status: 'ok' })
-            .mockRejectedValueOnce(new Error('fail 2'))
-            .mockRejectedValueOnce(new Error('fail 3'));
-        const manager = new PollManager({
-            pollFunction,
-            intervalMs: 100,
-            maxRetries: 2,
-            onError,
-            onStop,
-        });
-        manager.start();
-        await Promise.resolve();
-        jest.advanceTimersByTime(100);
-        await Promise.resolve();
-        expect(onStop).not.toHaveBeenCalled();
-        expect(onError).toHaveBeenCalledTimes(1);
-        jest.advanceTimersByTime(100);
-        await Promise.resolve();
-        jest.advanceTimersByTime(100);
-        await Promise.resolve();
-        expect(onStop).toHaveBeenCalled();
-        expect(onError).toHaveBeenCalledTimes(3);
-        manager.stop();
-    });
-});

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

@@ -1,4 +0,0 @@
-/**
- * Unit tests for streamable HTTP client
- */
-export {};