@inferencesh/sdk 0.5.10 → 0.5.11

package/dist/api/apps.d.ts

@@ -58,5 +58,9 @@ export declare class AppsAPI {
      * Save app license
      */
     saveLicense(appId: string, license: string): Promise<LicenseRecord>;
+    /**
+     * Set the current (active) version of an app
+     */
+    setCurrentVersion(appId: string, versionId: string): Promise<App>;
 }
 export declare function createAppsAPI(http: HttpClient): AppsAPI;

package/dist/api/apps.js

@@ -83,6 +83,12 @@ export class AppsAPI {
     async saveLicense(appId, license) {
         return this.http.request('post', `/apps/${appId}/license`, { data: { license } });
     }
+    /**
+     * Set the current (active) version of an app
+     */
+    async setCurrentVersion(appId, versionId) {
+        return this.http.request('post', `/apps/${appId}/current-version`, { data: { version_id: versionId } });
+    }
 }
 export function createAppsAPI(http) {
     return new AppsAPI(http);

package/dist/http/index.d.ts

@@ -1,3 +1,4 @@
 export { HttpClient, HttpClientConfig, ErrorHandler, createHttpClient } from './client';
 export { StreamManager, StreamManagerOptions, PartialDataWrapper } from './stream';
+export { streamable, streamableRaw, StreamableManager, StreamableOptions, StreamableMessage, StreamableManagerOptions } from './streamable';
 export { InferenceError, RequirementsNotMetException } from './errors';

package/dist/http/index.js

@@ -1,3 +1,4 @@
 export { HttpClient, createHttpClient } from './client';
 export { StreamManager } from './stream';
+export { streamable, streamableRaw, StreamableManager } from './streamable';
 export { InferenceError, RequirementsNotMetException } from './errors';

package/dist/http/streamable.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Streamable HTTP client using fetch + ReadableStream.
+ * This is the NDJSON alternative to SSE/EventSource that avoids
+ * the browser's ~6 connection limit per domain.
+ */
+export interface StreamableOptions {
+    /** Additional headers to include */
+    headers?: Record<string, string>;
+    /** Request body (will be JSON stringified) */
+    body?: unknown;
+    /** HTTP method (defaults to GET, or POST if body is provided) */
+    method?: 'GET' | 'POST';
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+    /** Skip heartbeat messages (default: true) */
+    skipHeartbeats?: boolean;
+}
+export interface StreamableMessage<T = unknown> {
+    /** Optional event type */
+    event?: string;
+    /** Data payload */
+    data?: T;
+    /** Updated fields (for partial updates) */
+    fields?: string[];
+    /** Message type (e.g., "heartbeat") */
+    type?: string;
+}
+/**
+ * Stream NDJSON from an HTTP endpoint using fetch + ReadableStream.
+ * Yields parsed JSON objects, automatically filtering heartbeats.
+ */
+export declare function streamable<T = unknown>(url: string, options?: StreamableOptions): AsyncGenerator<T>;
+/**
+ * StreamableManager provides a callback-based API similar to StreamManager
+ * but uses fetch + ReadableStream instead of EventSource.
+ */
+export interface StreamableManagerOptions<T> {
+    /** URL to connect to */
+    url: string;
+    /** Additional headers */
+    headers?: Record<string, string>;
+    /** Request body */
+    body?: unknown;
+    /** Called for each message */
+    onData?: (data: T) => void;
+    /** Called for partial updates with fields list */
+    onPartialData?: (data: T, fields: string[]) => void;
+    /** Called on error */
+    onError?: (error: Error) => void;
+    /** Called when stream starts */
+    onStart?: () => void;
+    /** Called when stream ends */
+    onEnd?: () => void;
+}
+export declare class StreamableManager<T> {
+    private options;
+    private abortController;
+    private isRunning;
+    constructor(options: StreamableManagerOptions<T>);
+    start(): Promise<void>;
+    stop(): void;
+}
+/**
+ * Raw streamable that yields the full message including wrapper.
+ * Use this when you need access to event type or fields.
+ */
+export declare function streamableRaw<T = unknown>(url: string, options?: StreamableOptions): AsyncGenerator<StreamableMessage<T> | T>;

package/dist/http/streamable.js

@@ -0,0 +1,195 @@
+/**
+ * Streamable HTTP client using fetch + ReadableStream.
+ * This is the NDJSON alternative to SSE/EventSource that avoids
+ * the browser's ~6 connection limit per domain.
+ */
+/**
+ * Stream NDJSON from an HTTP endpoint using fetch + ReadableStream.
+ * Yields parsed JSON objects, automatically filtering heartbeats.
+ */
+export async function* streamable(url, options = {}) {
+    const { headers = {}, body, method = body ? 'POST' : 'GET', signal, skipHeartbeats = true, } = options;
+    const requestHeaders = {
+        Accept: 'application/x-ndjson',
+        ...headers,
+    };
+    if (body) {
+        requestHeaders['Content-Type'] = 'application/json';
+    }
+    const res = await fetch(url, {
+        method,
+        headers: requestHeaders,
+        body: body ? JSON.stringify(body) : undefined,
+        signal,
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`HTTP ${res.status}: ${text}`);
+    }
+    if (!res.body) {
+        throw new Error('No response body');
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                const parsed = JSON.parse(line);
+                // Skip heartbeats
+                if (skipHeartbeats && parsed.type === 'heartbeat') {
+                    continue;
+                }
+                // If it's a wrapped message with event/data/fields, yield the data
+                // Otherwise yield the entire parsed object
+                if ('data' in parsed && parsed.data !== undefined) {
+                    yield parsed.data;
+                }
+                else {
+                    yield parsed;
+                }
+            }
+        }
+        // Handle remaining buffer
+        if (buffer.trim()) {
+            const parsed = JSON.parse(buffer);
+            if (!(skipHeartbeats && parsed.type === 'heartbeat')) {
+                if ('data' in parsed && parsed.data !== undefined) {
+                    yield parsed.data;
+                }
+                else {
+                    yield parsed;
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+export class StreamableManager {
+    constructor(options) {
+        this.abortController = null;
+        this.isRunning = false;
+        this.options = options;
+    }
+    async start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.abortController = new AbortController();
+        try {
+            this.options.onStart?.();
+            for await (const message of streamableRaw(this.options.url, {
+                headers: this.options.headers,
+                body: this.options.body,
+                signal: this.abortController.signal,
+            })) {
+                if (!this.isRunning)
+                    break;
+                // Check if it's a partial update
+                if (typeof message === 'object' &&
+                    message !== null &&
+                    'data' in message &&
+                    'fields' in message &&
+                    Array.isArray(message.fields)) {
+                    const wrapper = message;
+                    if (this.options.onPartialData && wrapper.data !== undefined) {
+                        this.options.onPartialData(wrapper.data, wrapper.fields);
+                    }
+                    else if (wrapper.data !== undefined) {
+                        this.options.onData?.(wrapper.data);
+                    }
+                }
+                else {
+                    this.options.onData?.(message);
+                }
+            }
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === 'AbortError') {
+                // Intentional stop, not an error
+            }
+            else {
+                this.options.onError?.(err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+        finally {
+            this.isRunning = false;
+            this.options.onEnd?.();
+        }
+    }
+    stop() {
+        this.isRunning = false;
+        this.abortController?.abort();
+        this.abortController = null;
+    }
+}
+/**
+ * Raw streamable that yields the full message including wrapper.
+ * Use this when you need access to event type or fields.
+ */
+export async function* streamableRaw(url, options = {}) {
+    const { headers = {}, body, method = body ? 'POST' : 'GET', signal, skipHeartbeats = true, } = options;
+    const requestHeaders = {
+        Accept: 'application/x-ndjson',
+        ...headers,
+    };
+    if (body) {
+        requestHeaders['Content-Type'] = 'application/json';
+    }
+    const res = await fetch(url, {
+        method,
+        headers: requestHeaders,
+        body: body ? JSON.stringify(body) : undefined,
+        signal,
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`HTTP ${res.status}: ${text}`);
+    }
+    if (!res.body) {
+        throw new Error('No response body');
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                const parsed = JSON.parse(line);
+                // Skip heartbeats
+                if (skipHeartbeats && parsed.type === 'heartbeat') {
+                    continue;
+                }
+                yield parsed;
+            }
+        }
+        // Handle remaining buffer
+        if (buffer.trim()) {
+            const parsed = JSON.parse(buffer);
+            if (!(skipHeartbeats && parsed.type === 'heartbeat')) {
+                yield parsed;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

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

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

package/dist/http/streamable.test.js

@@ -0,0 +1,410 @@
+/**
+ * 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');
+    });
+    // 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 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);
+    });
+});

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

@@ -0,0 +1,11 @@
+/**
+ * Integration tests for streamable HTTP client
+ *
+ * Tests NDJSON streaming against the real API.
+ * Run with: INFERENCE_API_KEY=xxx npm run test:integration
+ *
+ * Note: Format negotiation tests may be skipped if server doesn't support NDJSON yet.
+ *
+ * @jest-environment node
+ */
+export {};

package/dist/streamable.integration.test.js

@@ -0,0 +1,150 @@
+/**
+ * Integration tests for streamable HTTP client
+ *
+ * Tests NDJSON streaming against the real API.
+ * Run with: INFERENCE_API_KEY=xxx npm run test:integration
+ *
+ * Note: Format negotiation tests may be skipped if server doesn't support NDJSON yet.
+ *
+ * @jest-environment node
+ */
+import { streamable, StreamableManager } from './http/streamable';
+import { Inference, TaskStatusCompleted, TaskStatusFailed, TaskStatusCancelled } from './index';
+const isTerminalStatus = (status) => status === TaskStatusCompleted || status === TaskStatusFailed || status === TaskStatusCancelled;
+const API_KEY = process.env.INFERENCE_API_KEY;
+const BASE_URL = process.env.INFERENCE_BASE_URL || 'https://api.inference.sh';
+// Simple test app that completes quickly
+const TEST_APP = 'infsh/text-templating@53bk0yzk';
+const describeIfApiKey = API_KEY ? describe : describe.skip;
+describeIfApiKey('Streamable Integration Tests', () => {
+    let client;
+    beforeAll(() => {
+        client = new Inference({
+            apiKey: API_KEY,
+            baseUrl: BASE_URL,
+        });
+    });
+    describe('Format Negotiation', () => {
+        it('should negotiate format based on Accept header', async () => {
+            // Create a task using the SDK
+            const task = await client.run({ app: TEST_APP, input: { template: 'Format {1}!', strings: ['Test'] } }, { wait: false });
+            // Test NDJSON request
+            const ndjsonRes = await fetch(`${BASE_URL}/tasks/${task.id}/stream`, {
+                headers: {
+                    'Authorization': `Bearer ${API_KEY}`,
+                    'Accept': 'application/x-ndjson',
+                },
+            });
+            expect(ndjsonRes.ok).toBe(true);
+            const ndjsonContentType = ndjsonRes.headers.get('content-type');
+            // Test SSE request
+            const sseRes = await fetch(`${BASE_URL}/tasks/${task.id}/stream`, {
+                headers: {
+                    'Authorization': `Bearer ${API_KEY}`,
+                    'Accept': 'text/event-stream',
+                },
+            });
+            expect(sseRes.ok).toBe(true);
+            const sseContentType = sseRes.headers.get('content-type');
+            // Log what we got for debugging
+            console.log('NDJSON request Content-Type:', ndjsonContentType);
+            console.log('SSE request Content-Type:', sseContentType);
+            // At minimum, SSE should work
+            expect(sseContentType).toContain('text/event-stream');
+            // If NDJSON is supported, it should return NDJSON content-type
+            // Otherwise it falls back to SSE (server not yet updated)
+            const supportsNDJSON = ndjsonContentType?.includes('application/x-ndjson');
+            if (supportsNDJSON) {
+                console.log('✓ Server supports NDJSON format negotiation');
+            }
+            else {
+                console.log('⚠ Server does not yet support NDJSON, falling back to SSE');
+            }
+            // Clean up - consume the streams
+            for (const res of [ndjsonRes, sseRes]) {
+                const reader = res.body?.getReader();
+                if (reader) {
+                    while (true) {
+                        const { done } = await reader.read();
+                        if (done)
+                            break;
+                    }
+                }
+            }
+        }, 60000);
+    });
+    describe('streamable() with NDJSON server', () => {
+        // These tests require the server to support NDJSON
+        // Skip if server doesn't support it yet
+        it('should stream task updates when server supports NDJSON', async () => {
+            // Create a task using the SDK (fire and forget)
+            const task = await client.run({ app: TEST_APP, input: { template: 'Hello {1}!', strings: ['Streamable'] } }, { wait: false });
+            expect(task.id).toBeDefined();
+            // Stream updates using streamable - will request NDJSON format
+            const updates = [];
+            try {
+                for await (const update of streamable(`${BASE_URL}/tasks/${task.id}/stream`, {
+                    headers: { 'Authorization': `Bearer ${API_KEY}` },
+                })) {
+                    updates.push(update);
+                    // Stop when task reaches terminal status
+                    if (isTerminalStatus(update.status))
+                        break;
+                }
+            }
+            catch (err) {
+                // If server doesn't support NDJSON, streamable will fail to parse SSE
+                console.log('⚠ Skipping - server returned non-NDJSON:', err.message);
+                return;
+            }
+            expect(updates.length).toBeGreaterThan(0);
+            // Last update should be terminal
+            const lastUpdate = updates[updates.length - 1];
+            expect(isTerminalStatus(lastUpdate.status)).toBe(true);
+        }, 60000);
+    });
+    describe('StreamableManager with NDJSON server', () => {
+        it('should receive updates via callbacks when server supports NDJSON', async () => {
+            // Create a task using the SDK
+            const task = await client.run({ app: TEST_APP, input: { template: 'Manager {1}!', strings: ['Test'] } }, { wait: false });
+            const updates = [];
+            let started = false;
+            let ended = false;
+            let error = null;
+            const manager = new StreamableManager({
+                url: `${BASE_URL}/tasks/${task.id}/stream`,
+                headers: { 'Authorization': `Bearer ${API_KEY}` },
+                onStart: () => { started = true; },
+                onEnd: () => { ended = true; },
+                onData: (data) => {
+                    updates.push(data);
+                    // Stop when terminal
+                    if (isTerminalStatus(data.status)) {
+                        manager.stop();
+                    }
+                },
+                onError: (err) => {
+                    error = err;
+                },
+            });
+            await manager.start();
+            // If server doesn't support NDJSON, we'll get a parse error
+            if (error) {
+                console.log('⚠ Skipping StreamableManager test - server returned non-NDJSON');
+                return;
+            }
+            expect(started).toBe(true);
+            expect(ended).toBe(true);
+            expect(updates.length).toBeGreaterThan(0);
+        }, 60000);
+    });
+});
+// Ensure Jest doesn't complain when API key is not set
+describe('Streamable Integration Setup', () => {
+    it('checks for API key', () => {
+        if (!API_KEY) {
+            console.log('⚠️  Skipping streamable integration tests - INFERENCE_API_KEY not set');
+        }
+        expect(true).toBe(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inferencesh/sdk",
-  "version": "0.5.10",
+  "version": "0.5.11",
   "description": "Official JavaScript/TypeScript SDK for inference.sh - Run AI models with a simple API",
   "type": "module",
   "main": "dist/index.js",