@inferencesh/sdk 0.6.14 → 0.6.19

package/dist/http/streamable.test.js

@@ -1,510 +0,0 @@
-/**
- * Unit tests for streamable HTTP client
- */
-import { streamable, streamableRaw, StreamableManager } from './streamable';
-// Mock fetch for unit tests
-const mockFetch = (chunks) => {
-    let chunkIndex = 0;
-    const mockReader = {
-        read: jest.fn().mockImplementation(async () => {
-            if (chunkIndex >= chunks.length) {
-                return { done: true, value: undefined };
-            }
-            const chunk = chunks[chunkIndex++];
-            return { done: false, value: new TextEncoder().encode(chunk) };
-        }),
-        releaseLock: jest.fn(),
-    };
-    return jest.fn().mockResolvedValue({
-        ok: true,
-        status: 200,
-        body: {
-            getReader: () => mockReader,
-        },
-    });
-};
-describe('streamable', () => {
-    const originalFetch = global.fetch;
-    afterEach(() => {
-        global.fetch = originalFetch;
-    });
-    it('should parse NDJSON lines', async () => {
-        global.fetch = mockFetch([
-            '{"id":1,"name":"first"}\n',
-            '{"id":2,"name":"second"}\n',
-        ]);
-        const results = [];
-        for await (const item of streamable('http://test.com/stream')) {
-            results.push(item);
-        }
-        expect(results).toHaveLength(2);
-        expect(results[0]).toEqual({ id: 1, name: 'first' });
-        expect(results[1]).toEqual({ id: 2, name: 'second' });
-    });
-    it('should skip heartbeats by default', async () => {
-        global.fetch = mockFetch([
-            '{"id":1}\n',
-            '{"type":"heartbeat"}\n',
-            '{"id":2}\n',
-        ]);
-        const results = [];
-        for await (const item of streamable('http://test.com/stream')) {
-            results.push(item);
-        }
-        expect(results).toHaveLength(2);
-        expect(results[0]).toEqual({ id: 1 });
-        expect(results[1]).toEqual({ id: 2 });
-    });
-    it('should include heartbeats when skipHeartbeats is false', async () => {
-        global.fetch = mockFetch([
-            '{"id":1}\n',
-            '{"type":"heartbeat"}\n',
-            '{"id":2}\n',
-        ]);
-        const results = [];
-        for await (const item of streamable('http://test.com/stream', { skipHeartbeats: false })) {
-            results.push(item);
-        }
-        expect(results).toHaveLength(3);
-    });
-    it('should unwrap data from wrapped messages', async () => {
-        global.fetch = mockFetch([
-            '{"data":{"id":1},"fields":["id"]}\n',
-            '{"event":"update","data":{"id":2}}\n',
-        ]);
-        const results = [];
-        for await (const item of streamable('http://test.com/stream')) {
-            results.push(item);
-        }
-        expect(results).toHaveLength(2);
-        expect(results[0]).toEqual({ id: 1 });
-        expect(results[1]).toEqual({ id: 2 });
-    });
-    it('should handle chunked data across multiple reads', async () => {
-        global.fetch = mockFetch([
-            '{"id":1}\n{"id":', // First chunk ends mid-JSON
-            '2}\n', // Second chunk completes it
-        ]);
-        const results = [];
-        for await (const item of streamable('http://test.com/stream')) {
-            results.push(item);
-        }
-        expect(results).toHaveLength(2);
-        expect(results[0]).toEqual({ id: 1 });
-        expect(results[1]).toEqual({ id: 2 });
-    });
-    it('should handle empty lines', async () => {
-        global.fetch = mockFetch([
-            '{"id":1}\n',
-            '\n',
-            '{"id":2}\n',
-            '\n\n',
-        ]);
-        const results = [];
-        for await (const item of streamable('http://test.com/stream')) {
-            results.push(item);
-        }
-        expect(results).toHaveLength(2);
-    });
-    it('should set correct headers', async () => {
-        const mockFetchFn = mockFetch(['{"ok":true}\n']);
-        global.fetch = mockFetchFn;
-        const results = [];
-        for await (const item of streamable('http://test.com/stream', {
-            headers: { 'Authorization': 'Bearer token' },
-        })) {
-            results.push(item);
-        }
-        expect(mockFetchFn).toHaveBeenCalledWith('http://test.com/stream', expect.objectContaining({
-            method: 'GET',
-            headers: expect.objectContaining({
-                'Accept': 'application/x-ndjson',
-                'Authorization': 'Bearer token',
-            }),
-        }));
-    });
-    it('should use POST when body is provided', async () => {
-        const mockFetchFn = mockFetch(['{"ok":true}\n']);
-        global.fetch = mockFetchFn;
-        const results = [];
-        for await (const item of streamable('http://test.com/stream', {
-            body: { query: 'test' },
-        })) {
-            results.push(item);
-        }
-        expect(mockFetchFn).toHaveBeenCalledWith('http://test.com/stream', expect.objectContaining({
-            method: 'POST',
-            headers: expect.objectContaining({
-                'Content-Type': 'application/json',
-            }),
-            body: JSON.stringify({ query: 'test' }),
-        }));
-    });
-    it('should throw on HTTP error', async () => {
-        global.fetch = jest.fn().mockResolvedValue({
-            ok: false,
-            status: 401,
-            text: async () => 'Unauthorized',
-        });
-        await expect(async () => {
-            for await (const _ of streamable('http://test.com/stream')) {
-                // consume
-            }
-        }).rejects.toThrow('HTTP 401: Unauthorized');
-    });
-    it('should throw when the response has no body', async () => {
-        global.fetch = jest.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            body: null,
-        });
-        await expect(async () => {
-            for await (const _ of streamable('http://test.com/stream')) {
-                // consume
-            }
-        }).rejects.toThrow('No response body');
-    });
-    // Edge cases for chunking/buffering
-    describe('chunking edge cases', () => {
-        it('should handle message split across many chunks', async () => {
-            // Split a single JSON object into 5 tiny chunks
-            global.fetch = mockFetch([
-                '{"id":',
-                '123,',
-                '"name"',
-                ':"test',
-                '"}\n',
-            ]);
-            const results = [];
-            for await (const item of streamable('http://test.com/stream')) {
-                results.push(item);
-            }
-            expect(results).toHaveLength(1);
-            expect(results[0]).toEqual({ id: 123, name: 'test' });
-        });
-        it('should handle single-byte chunks', async () => {
-            const json = '{"id":1}\n';
-            const chunks = json.split('').map(c => c); // One char per chunk
-            global.fetch = mockFetch(chunks);
-            const results = [];
-            for await (const item of streamable('http://test.com/stream')) {
-                results.push(item);
-            }
-            expect(results).toHaveLength(1);
-            expect(results[0]).toEqual({ id: 1 });
-        });
-        it('should handle newline exactly at chunk boundary', async () => {
-            global.fetch = mockFetch([
-                '{"id":1}',
-                '\n',
-                '{"id":2}\n',
-            ]);
-            const results = [];
-            for await (const item of streamable('http://test.com/stream')) {
-                results.push(item);
-            }
-            expect(results).toHaveLength(2);
-        });
-        it('should handle multiple messages in single chunk', async () => {
-            global.fetch = mockFetch([
-                '{"id":1}\n{"id":2}\n{"id":3}\n',
-            ]);
-            const results = [];
-            for await (const item of streamable('http://test.com/stream')) {
-                results.push(item);
-            }
-            expect(results).toHaveLength(3);
-        });
-        it('should handle empty chunks', async () => {
-            global.fetch = mockFetch([
-                '{"id":1}\n',
-                '',
-                '',
-                '{"id":2}\n',
-            ]);
-            const results = [];
-            for await (const item of streamable('http://test.com/stream')) {
-                results.push(item);
-            }
-            expect(results).toHaveLength(2);
-        });
-        it('should handle trailing data without final newline', async () => {
-            global.fetch = mockFetch([
-                '{"id":1}\n',
-                '{"id":2}', // No trailing newline
-            ]);
-            const results = [];
-            for await (const item of streamable('http://test.com/stream')) {
-                results.push(item);
-            }
-            expect(results).toHaveLength(2);
-        });
-    });
-    describe('unicode handling', () => {
-        it('should handle unicode in messages', async () => {
-            global.fetch = mockFetch([
-                '{"text":"Hello 世界 🎉"}\n',
-            ]);
-            const results = [];
-            for await (const item of streamable('http://test.com/stream')) {
-                results.push(item);
-            }
-            expect(results[0]).toEqual({ text: 'Hello 世界 🎉' });
-        });
-        it('should handle unicode split across chunks', async () => {
-            // 世 is 3 bytes in UTF-8: E4 B8 96
-            // Split it across chunks
-            const encoder = new TextEncoder();
-            const fullText = '{"text":"世"}\n';
-            const bytes = encoder.encode(fullText);
-            // Create mock that returns raw bytes split mid-character
-            let chunkIndex = 0;
-            const chunks = [
-                bytes.slice(0, 10), // '{"text":"' + first byte of 世
-                bytes.slice(10), // rest of 世 + '"}\n'
-            ];
-            const mockReader = {
-                read: jest.fn().mockImplementation(async () => {
-                    if (chunkIndex >= chunks.length) {
-                        return { done: true, value: undefined };
-                    }
-                    return { done: false, value: chunks[chunkIndex++] };
-                }),
-                releaseLock: jest.fn(),
-            };
-            global.fetch = jest.fn().mockResolvedValue({
-                ok: true,
-                body: { getReader: () => mockReader },
-            });
-            const results = [];
-            for await (const item of streamable('http://test.com/stream')) {
-                results.push(item);
-            }
-            expect(results[0]).toEqual({ text: '世' });
-        });
-    });
-    describe('error handling', () => {
-        it('should handle invalid JSON gracefully', async () => {
-            global.fetch = mockFetch([
-                '{"id":1}\n',
-                'not valid json\n',
-                '{"id":2}\n',
-            ]);
-            const results = [];
-            await expect(async () => {
-                for await (const item of streamable('http://test.com/stream')) {
-                    results.push(item);
-                }
-            }).rejects.toThrow(); // Should throw on invalid JSON
-            // First valid message should have been processed
-            expect(results).toHaveLength(1);
-        });
-        it('should handle network error mid-stream', async () => {
-            let readCount = 0;
-            const mockReader = {
-                read: jest.fn().mockImplementation(async () => {
-                    readCount++;
-                    if (readCount === 1) {
-                        return { done: false, value: new TextEncoder().encode('{"id":1}\n') };
-                    }
-                    throw new Error('Network error');
-                }),
-                releaseLock: jest.fn(),
-            };
-            global.fetch = jest.fn().mockResolvedValue({
-                ok: true,
-                body: { getReader: () => mockReader },
-            });
-            const results = [];
-            await expect(async () => {
-                for await (const item of streamable('http://test.com/stream')) {
-                    results.push(item);
-                }
-            }).rejects.toThrow('Network error');
-            expect(results).toHaveLength(1);
-        });
-    });
-});
-describe('streamableRaw', () => {
-    const originalFetch = global.fetch;
-    afterEach(() => {
-        global.fetch = originalFetch;
-    });
-    it('should preserve event and fields in raw mode', async () => {
-        global.fetch = mockFetch([
-            '{"event":"update","data":{"id":1},"fields":["id"]}\n',
-        ]);
-        const results = [];
-        for await (const item of streamableRaw('http://test.com/stream')) {
-            results.push(item);
-        }
-        expect(results).toHaveLength(1);
-        expect(results[0]).toEqual({
-            event: 'update',
-            data: { id: 1 },
-            fields: ['id'],
-        });
-    });
-});
-describe('StreamableManager', () => {
-    const originalFetch = global.fetch;
-    afterEach(() => {
-        global.fetch = originalFetch;
-    });
-    it('should call onData for each message', async () => {
-        global.fetch = mockFetch([
-            '{"id":1}\n',
-            '{"id":2}\n',
-        ]);
-        const messages = [];
-        const manager = new StreamableManager({
-            url: 'http://test.com/stream',
-            onData: (data) => messages.push(data),
-        });
-        await manager.start();
-        expect(messages).toHaveLength(2);
-        expect(messages[0]).toEqual({ id: 1 });
-        expect(messages[1]).toEqual({ id: 2 });
-    });
-    it('should call onPartialData for partial updates', async () => {
-        global.fetch = mockFetch([
-            '{"data":{"id":1},"fields":["id"]}\n',
-        ]);
-        const partials = [];
-        const manager = new StreamableManager({
-            url: 'http://test.com/stream',
-            onPartialData: (data, fields) => partials.push({ data, fields }),
-        });
-        await manager.start();
-        expect(partials).toHaveLength(1);
-        expect(partials[0]).toEqual({ data: { id: 1 }, fields: ['id'] });
-    });
-    it('should call lifecycle callbacks', async () => {
-        global.fetch = mockFetch(['{"ok":true}\n']);
-        const events = [];
-        const manager = new StreamableManager({
-            url: 'http://test.com/stream',
-            onStart: () => events.push('start'),
-            onEnd: () => events.push('end'),
-            onData: () => events.push('data'),
-        });
-        await manager.start();
-        expect(events).toEqual(['start', 'data', 'end']);
-    });
-    it('should dispatch typed events to addEventListener subscribers', async () => {
-        global.fetch = mockFetch([
-            '{"event":"chats","data":{"id":"chat-1","status":"busy"}}\n',
-            '{"event":"chat_messages","data":{"id":"msg-1","content":"hi"}}\n',
-        ]);
-        const onChat = jest.fn();
-        const onMessage = jest.fn();
-        const manager = new StreamableManager({
-            url: 'http://test.com/stream',
-            onData: jest.fn(),
-        });
-        manager.addEventListener('chats', onChat);
-        manager.addEventListener('chat_messages', onMessage);
-        await manager.start();
-        expect(onChat).toHaveBeenCalledWith({ id: 'chat-1', status: 'busy' });
-        expect(onMessage).toHaveBeenCalledWith({ id: 'msg-1', content: 'hi' });
-    });
-    it('should stop dispatching to an unsubscribed listener', async () => {
-        global.fetch = mockFetch([
-            '{"event":"chats","data":{"id":"chat-1"}}\n',
-        ]);
-        const removedListener = jest.fn();
-        const activeListener = jest.fn();
-        const manager = new StreamableManager({
-            url: 'http://test.com/stream',
-        });
-        const unsubscribe = manager.addEventListener('chats', removedListener);
-        manager.addEventListener('chats', activeListener);
-        unsubscribe();
-        await manager.start();
-        expect(removedListener).not.toHaveBeenCalled();
-        expect(activeListener).toHaveBeenCalledWith({ id: 'chat-1' });
-    });
-    it('should ignore start() when a stream is already running', async () => {
-        let readCount = 0;
-        const mockReader = {
-            read: jest.fn().mockImplementation(async () => {
-                readCount++;
-                if (readCount > 3) {
-                    return { done: true, value: undefined };
-                }
-                await new Promise((resolve) => setTimeout(resolve, 20));
-                return { done: false, value: new TextEncoder().encode('{"id":1}\n') };
-            }),
-            releaseLock: jest.fn(),
-        };
-        global.fetch = jest.fn().mockResolvedValue({
-            ok: true,
-            body: { getReader: () => mockReader },
-        });
-        const onStart = jest.fn();
-        const manager = new StreamableManager({
-            url: 'http://test.com/stream',
-            onStart,
-            onData: () => { },
-        });
-        const firstStart = manager.start();
-        await manager.start();
-        await firstStart;
-        expect(onStart).toHaveBeenCalledTimes(1);
-        expect(global.fetch).toHaveBeenCalledTimes(1);
-    });
-    it('should handle stop()', async () => {
-        let readCount = 0;
-        const mockReader = {
-            read: jest.fn().mockImplementation(async () => {
-                readCount++;
-                if (readCount > 10) {
-                    return { done: true, value: undefined };
-                }
-                await new Promise(resolve => setTimeout(resolve, 10));
-                return { done: false, value: new TextEncoder().encode('{"id":1}\n') };
-            }),
-            releaseLock: jest.fn(),
-        };
-        global.fetch = jest.fn().mockResolvedValue({
-            ok: true,
-            body: { getReader: () => mockReader },
-        });
-        const manager = new StreamableManager({
-            url: 'http://test.com/stream',
-            onData: () => { },
-        });
-        // Start and immediately stop
-        const startPromise = manager.start();
-        setTimeout(() => manager.stop(), 25);
-        await startPromise;
-        // Should have stopped before reading all 10
-        expect(readCount).toBeLessThan(10);
-    });
-    it('should call onError when the stream request fails', async () => {
-        global.fetch = jest.fn().mockResolvedValue({
-            ok: false,
-            status: 503,
-            text: async () => 'Service unavailable',
-        });
-        const onError = jest.fn();
-        const manager = new StreamableManager({
-            url: 'http://test.com/stream',
-            onError,
-        });
-        await manager.start();
-        expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'HTTP 503: Service unavailable' }));
-    });
-    it('should route partial updates to onData when onPartialData is not provided', async () => {
-        global.fetch = mockFetch([
-            '{"data":{"id":1,"status":"busy"},"fields":["status"]}\n',
-        ]);
-        const onData = jest.fn();
-        const manager = new StreamableManager({
-            url: 'http://test.com/stream',
-            onData,
-        });
-        await manager.start();
-        expect(onData).toHaveBeenCalledWith({ id: 1, status: 'busy' });
-    });
-});

package/dist/integration.test.d.ts

@@ -1,9 +0,0 @@
-/**
- * Integration tests for @inferencesh/sdk
- *
- * These tests hit the real API and require INFERENCE_API_KEY to be set.
- * Run with: npm run test:integration
- *
- * @jest-environment node
- */
-export {};

package/dist/integration.test.js

@@ -1,107 +0,0 @@
-/**
- * Integration tests for @inferencesh/sdk
- *
- * These tests hit the real API and require INFERENCE_API_KEY to be set.
- * Run with: npm run test:integration
- *
- * @jest-environment node
- */
-import { Inference, inference } from './index';
-import { TaskStatusCompleted, TaskStatusFailed } from './types';
-// Skip all tests if no API key is set
-const API_KEY = process.env.INFERENCE_API_KEY;
-const BASE_URL = process.env.INFERENCE_BASE_URL || 'https://api.inference.sh';
-// Use a pinned app version that's known to work
-const TEST_APP = 'infsh/text-templating@53bk0yzk';
-const describeIfApiKey = API_KEY ? describe : describe.skip;
-describeIfApiKey('Integration Tests', () => {
-    let client;
-    beforeAll(() => {
-        client = new Inference({
-            apiKey: API_KEY,
-            baseUrl: BASE_URL,
-        });
-    });
-    describe('Basic Run', () => {
-        it('should run a simple task and wait for completion', async () => {
-            const result = await client.run({
-                app: TEST_APP,
-                input: { template: 'Hello {1}!', strings: ['Jest'] },
-            });
-            expect(result).toBeDefined();
-            expect(result.id).toBeDefined();
-            expect(result.status).toBe(TaskStatusCompleted);
-            expect(result.output).toBeDefined();
-        }, 60000); // 60 second timeout for API call
-    });
-    describe('Run with Updates', () => {
-        it('should receive status updates during task execution', async () => {
-            const updates = [];
-            const result = await client.run({
-                app: TEST_APP,
-                input: { template: 'Testing {1}', strings: ['SDK'] },
-            }, {
-                onUpdate: (update) => {
-                    updates.push(update.status);
-                },
-            });
-            expect(result.status).toBe(TaskStatusCompleted);
-            expect(updates.length).toBeGreaterThan(0);
-        }, 60000);
-    });
-    describe('Fire and Forget', () => {
-        it('should submit a task without waiting for completion', async () => {
-            const result = await client.run({
-                app: TEST_APP,
-                input: { template: '{1}', strings: ['Fire and forget'] },
-            }, { wait: false });
-            expect(result).toBeDefined();
-            expect(result.id).toBeDefined();
-            // Status should NOT be completed yet (task was just submitted)
-            expect(result.status).not.toBe(TaskStatusCompleted);
-            expect(result.status).not.toBe(TaskStatusFailed);
-        }, 30000);
-    });
-    describe('Factory Function', () => {
-        it('should work with lowercase inference() factory', async () => {
-            const factoryClient = inference({
-                apiKey: API_KEY,
-                baseUrl: BASE_URL,
-            });
-            const result = await factoryClient.run({
-                app: TEST_APP,
-                input: { template: '{1}', strings: ['Factory test'] },
-            }, { wait: false });
-            expect(result).toBeDefined();
-            expect(result.id).toBeDefined();
-        }, 30000);
-    });
-    describe('Webhook', () => {
-        it('should deliver webhook on task completion', async () => {
-            const result = await client.run({
-                app: TEST_APP,
-                input: { template: 'Webhook test {1}', strings: ['hello'] },
-                webhook: 'https://webhook.site/bbe9ba01-3ab2-4056-a1b1-1cf6969987d5',
-            });
-            expect(result.status).toBe(TaskStatusCompleted);
-            expect(result.output).toBeDefined();
-        }, 60000);
-    });
-    describe('Error Handling', () => {
-        it('should throw an error for non-existent app', async () => {
-            await expect(client.run({
-                app: 'non-existent/app-that-does-not-exist@xyz123',
-                input: {},
-            }, { wait: false })).rejects.toThrow();
-        }, 30000);
-    });
-});
-// Add a simple test that always runs to ensure Jest doesn't complain about no tests
-describe('Integration Test Setup', () => {
-    it('should have API key check', () => {
-        if (!API_KEY) {
-            console.log('⚠️  Skipping integration tests - INFERENCE_API_KEY not set');
-        }
-        expect(true).toBe(true);
-    });
-});

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

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