@inferencesh/sdk 0.5.11 → 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/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/streamable.d.ts

@@ -56,7 +56,13 @@ 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;
 }

package/dist/http/streamable.js

@@ -79,8 +79,28 @@ 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;
@@ -95,13 +115,20 @@ export class StreamableManager {
             })) {
                 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(message.fields)) {
-                    const wrapper = message;
+                    Array.isArray(wrapper.fields)) {
                     if (this.options.onPartialData && wrapper.data !== undefined) {
                         this.options.onPartialData(wrapper.data, wrapper.fields);
                     }
@@ -109,6 +136,10 @@ export class StreamableManager {
                         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);
                 }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inferencesh/sdk",
-  "version": "0.5.11",
+  "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",