@inferencesh/sdk 0.5.10 → 0.5.12

package/dist/agent/actions.js

@@ -5,7 +5,7 @@
  * These are created once per provider instance with access to dispatch.
  */
 import { ToolInvocationStatusAwaitingInput, ToolTypeClient, ChatStatusBusy, } from '../types';
-import { StreamManager } from '../http/stream';
+import { StreamableManager } from '../http/streamable';
 import { PollManager } from '../http/poll';
 import { isAdHocConfig, extractClientToolHandlers } from './types';
 import * as api from './api';
@@ -99,11 +99,10 @@ export function createActions(ctx) {
             return;
         }
         // Single unified stream with TypedEvents (both Chat and ChatMessage events)
-        const manager = new StreamManager({
-            createEventSource: () => api.createUnifiedStream(client, id),
-            autoReconnect: true,
-            maxReconnects: 3,
-            reconnectDelayMs: 3000,
+        const { url, headers } = api.getChatStreamConfig(client, id);
+        const manager = new StreamableManager({
+            url,
+            headers,
             onError: (error) => {
                 console.warn('[AgentSDK] Stream error:', error);
                 callbacks.onError?.(error);
@@ -112,7 +111,7 @@ export function createActions(ctx) {
                 dispatch({ type: 'SET_STATUS', payload: 'streaming' });
                 callbacks.onStatusChange?.('streaming');
             },
-            onStop: () => {
+            onEnd: () => {
                 // Only reset if this is an unexpected stop (stream died, max reconnects exhausted).
                 // If stopStream() was called intentionally, it clears the manager ref first,
                 // so getStreamManager() will be undefined and we skip the duplicate dispatch.
@@ -133,7 +132,7 @@ export function createActions(ctx) {
             updateMessage(message);
         });
         setStreamManager(manager);
-        manager.connect();
+        manager.start();
     };
     /** Poll-based alternative to streaming for restricted environments */
     const pollChat = (id) => {

package/dist/agent/api.d.ts

@@ -69,6 +69,9 @@ export declare function alwaysAllowTool(client: AgentClient, chatId: string, too
  */
 export declare function uploadFile(client: AgentClient, file: globalThis.File): Promise<UploadedFile>;
 /**
- * Create a unified stream for chat events
+ * Get streamable config for chat streaming (NDJSON)
  */
-export declare function createUnifiedStream(client: AgentClient, chatId: string): Promise<EventSource | null>;
+export declare function getChatStreamConfig(client: AgentClient, chatId: string): {
+    url: string;
+    headers: Record<string, string>;
+};

package/dist/agent/api.js

@@ -204,8 +204,8 @@ export async function uploadFile(client, file) {
     return result;
 }
 /**
- * Create a unified stream for chat events
+ * Get streamable config for chat streaming (NDJSON)
  */
-export function createUnifiedStream(client, chatId) {
-    return client.http.createEventSource(`/chats/${chatId}/stream`);
+export function getChatStreamConfig(client, chatId) {
+    return client.http.getStreamableConfig(`/chats/${chatId}/stream`);
 }

package/dist/agent/types.d.ts

@@ -6,7 +6,7 @@
 import type { Dispatch } from 'react';
 import type { ChatDTO, ChatMessageDTO, AgentTool, AgentConfig as GeneratedAgentConfig, CoreAppConfig } from '../types';
 import type { HttpClient } from '../http/client';
-import type { StreamManager } from '../http/stream';
+import type { StreamableManager } from '../http/streamable';
 import type { PollManager } from '../http/poll';
 /**
  * Minimal file interface returned by upload (just needs uri and content_type)
@@ -21,7 +21,7 @@ export interface UploadedFile {
  */
 export interface AgentClient {
     /** HTTP client for API requests */
-    http: Pick<HttpClient, 'request' | 'createEventSource' | 'getStreamDefault' | 'getPollIntervalMs'>;
+    http: Pick<HttpClient, 'request' | 'getStreamableConfig' | 'getStreamDefault' | 'getPollIntervalMs'>;
     /** Files API for uploads */
     files: {
         upload: (data: string | Blob | globalThis.File) => Promise<UploadedFile>;
@@ -209,7 +209,7 @@ export type ChatAction = {
  * Context for action creators
  */
 /** Union of manager types used for real-time updates */
-export type UpdateManager = StreamManager<unknown> | PollManager<unknown>;
+export type UpdateManager = StreamableManager<unknown> | PollManager<unknown>;
 export interface ActionsContext {
     client: AgentClient;
     dispatch: Dispatch<ChatAction>;

package/dist/api/agents.js

@@ -1,4 +1,4 @@
-import { StreamManager } from '../http/stream';
+import { StreamableManager } from '../http/streamable';
 import { PollManager } from '../http/poll';
 import { ToolTypeClient, ToolInvocationStatusAwaitingInput, ChatStatusBusy, } from '../types';
 /**
@@ -144,11 +144,12 @@ export class Agent {
     streamUntilIdle(options) {
         if (!this.chatId)
             return Promise.resolve();
+        const { url, headers } = this.http.getStreamableConfig(`/chats/${this.chatId}/stream`);
         return new Promise((resolve) => {
             this.stream?.stop();
-            this.stream = new StreamManager({
-                createEventSource: async () => this.http.createEventSource(`/chats/${this.chatId}/stream`),
-                autoReconnect: true,
+            this.stream = new StreamableManager({
+                url,
+                headers,
             });
             this.stream.addEventListener('chats', (chat) => {
                 options.onChat?.(chat);
@@ -173,7 +174,7 @@ export class Agent {
                     }
                 }
             });
-            this.stream.connect();
+            this.stream.start();
         });
     }
     /** Poll until chat becomes idle, dispatching callbacks on changes */

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/api/tasks.js

@@ -1,4 +1,4 @@
-import { StreamManager } from '../http/stream';
+import { StreamableManager } from '../http/streamable';
 import { PollManager } from '../http/poll';
 import { TaskStatusCompleted, TaskStatusFailed, TaskStatusCancelled, } from '../types';
 import { parseStatus } from '../utils';
@@ -84,15 +84,14 @@ export class TasksAPI {
         if (!useStream) {
             return this.pollUntilTerminal(task, options);
         }
-        // Wait for completion with optional updates via SSE
+        // Wait for completion with optional updates via NDJSON streaming
         // Accumulate state across partial updates to preserve fields like session_id
         let accumulatedTask = { ...task };
+        const { url, headers } = this.http.getStreamableConfig(`/tasks/${task.id}/stream`);
         return new Promise((resolve, reject) => {
-            const streamManager = new StreamManager({
-                createEventSource: async () => this.http.createEventSource(`/tasks/${task.id}/stream`),
-                autoReconnect,
-                maxReconnects,
-                reconnectDelayMs,
+            const streamManager = new StreamableManager({
+                url,
+                headers,
                 onData: (data) => {
                     // Merge new data, preserving existing fields if not in update
                     accumulatedTask = { ...accumulatedTask, ...data };
@@ -134,7 +133,7 @@ export class TasksAPI {
                     streamManager.stop();
                 },
             });
-            streamManager.connect();
+            streamManager.start();
         });
     }
     /** Poll GET /tasks/{id}/status until terminal, full-fetch on status change. */

package/dist/http/client.d.ts

@@ -76,8 +76,17 @@ export declare class HttpClient {
      * Execute the actual HTTP request (internal)
      */
     private executeRequest;
+    /**
+     * Get URL and headers for NDJSON streaming.
+     * Returns the full URL and auth headers needed for streamable requests.
+     */
+    getStreamableConfig(endpoint: string): {
+        url: string;
+        headers: Record<string, string>;
+    };
     /**
      * Create an EventSource for SSE streaming
+     * @deprecated Use getStreamableConfig() with StreamableManager instead
      */
     createEventSource(endpoint: string): Promise<EventSource | null>;
 }

package/dist/http/client.js

@@ -161,8 +161,33 @@ export class HttpClient {
         }
         return apiResponse.data;
     }
+    /**
+     * Get URL and headers for NDJSON streaming.
+     * Returns the full URL and auth headers needed for streamable requests.
+     */
+    getStreamableConfig(endpoint) {
+        const targetUrl = new URL(`${this.baseUrl}${endpoint}`);
+        const isProxyMode = !!this.proxyUrl;
+        let url;
+        const headers = { ...this.resolveHeaders() };
+        if (isProxyMode) {
+            const proxyUrlWithQuery = new URL(this.proxyUrl, typeof window !== 'undefined' ? window.location.origin : 'http://localhost');
+            proxyUrlWithQuery.searchParams.set('__inf_target', targetUrl.toString());
+            url = proxyUrlWithQuery.toString();
+            headers['x-inf-target-url'] = targetUrl.toString();
+        }
+        else {
+            url = targetUrl.toString();
+            const token = this.getAuthToken();
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+        }
+        return { url, headers };
+    }
     /**
      * Create an EventSource for SSE streaming
+     * @deprecated Use getStreamableConfig() with StreamableManager instead
      */
     createEventSource(endpoint) {
         const targetUrl = new URL(`${this.baseUrl}${endpoint}`);

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,73 @@
+/**
+ * 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;
+    private eventListeners;
+    constructor(options: StreamableManagerOptions<T>);
+    /**
+     * Add a listener for typed events (e.g., 'chats', 'chat_messages').
+     * Used when server sends events with {"event": "eventName", "data": ...} format.
+     */
+    addEventListener<E = unknown>(eventName: string, callback: (data: E) => void): () => void;
+    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,226 @@
+/**
+ * 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.eventListeners = new Map();
+        this.options = options;
+    }
+    /**
+     * Add a listener for typed events (e.g., 'chats', 'chat_messages').
+     * Used when server sends events with {"event": "eventName", "data": ...} format.
+     */
+    addEventListener(eventName, callback) {
+        const listeners = this.eventListeners.get(eventName) || new Set();
+        listeners.add(callback);
+        this.eventListeners.set(eventName, listeners);
+        // Return cleanup function
+        return () => {
+            const listeners = this.eventListeners.get(eventName);
+            if (listeners) {
+                listeners.delete(callback);
+                if (listeners.size === 0) {
+                    this.eventListeners.delete(eventName);
+                }
+            }
+        };
+    }
+    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;
+                const wrapper = message;
+                // Handle typed events ({"event": "...", "data": ...})
+                if (wrapper.event && this.eventListeners.has(wrapper.event)) {
+                    const listeners = this.eventListeners.get(wrapper.event);
+                    const eventData = wrapper.data !== undefined ? wrapper.data : message;
+                    listeners.forEach(callback => callback(eventData));
+                    continue;
+                }
+                // Check if it's a partial update
+                if (typeof message === 'object' &&
+                    message !== null &&
+                    'data' in message &&
+                    'fields' in message &&
+                    Array.isArray(wrapper.fields)) {
+                    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 if (wrapper.data !== undefined) {
+                    // Has data wrapper but no fields - unwrap
+                    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/index.d.ts

@@ -1,5 +1,6 @@
 export { HttpClient, HttpClientConfig, ErrorHandler, createHttpClient } from './http/client';
 export { StreamManager, StreamManagerOptions, PartialDataWrapper } from './http/stream';
+export { StreamableManager, StreamableManagerOptions, StreamableMessage, streamable, streamableRaw } from './http/streamable';
 export { PollManager, PollManagerOptions } from './http/poll';
 export { InferenceError, RequirementsNotMetException, SessionError, SessionNotFoundError, SessionExpiredError, SessionEndedError, WorkerLostError, isRequirementsNotMetException, isInferenceError, isSessionError, } from './http/errors';
 export { TasksAPI, RunOptions } from './api/tasks';

package/dist/index.js

@@ -1,6 +1,7 @@
 // HTTP utilities
 export { HttpClient, createHttpClient } from './http/client';
 export { StreamManager } from './http/stream';
+export { StreamableManager, streamable, streamableRaw } from './http/streamable';
 export { PollManager } from './http/poll';
 export { InferenceError, RequirementsNotMetException, SessionError, SessionNotFoundError, SessionExpiredError, SessionEndedError, WorkerLostError, 
 // Type guards (use these instead of instanceof for reliability)

package/dist/proxy/express.js

@@ -40,6 +40,7 @@ export function createHandler(options) {
                 // Handle streaming responses
                 const contentType = response.headers.get("content-type");
                 if (contentType?.includes("text/event-stream") ||
+                    contentType?.includes("application/x-ndjson") ||
                     contentType?.includes("application/octet-stream")) {
                     if (response.body) {
                         const reader = response.body.getReader();

package/dist/proxy/index.js

@@ -110,12 +110,13 @@ export async function processProxyRequest(adapter, options) {
     const userAgent = firstValue(adapter.header("user-agent"));
     const proxyId = `@inferencesh/sdk-proxy/${adapter.framework}`;
     // 6. Make upstream request
+    const accept = firstValue(adapter.header("accept"));
     const response = await fetch(targetUrl, {
         method: adapter.method,
         headers: {
             ...forwardHeaders,
             authorization: firstValue(adapter.header("authorization")) ?? `Bearer ${apiKey}`,
-            accept: "application/json",
+            accept: accept || "application/json",
             "content-type": contentType || "application/json",
             "user-agent": userAgent || proxyId,
             "x-inf-proxy": proxyId,

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.12",
   "description": "Official JavaScript/TypeScript SDK for inference.sh - Run AI models with a simple API",
   "type": "module",
   "main": "dist/index.js",