@inferencesh/sdk 0.5.11 → 0.5.13

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';
@@ -77,7 +77,7 @@ export function createActions(ctx) {
             existingManager.stop();
         }
         setStreamManager(undefined);
-        dispatch({ type: 'SET_STATUS', payload: 'connecting' });
+        dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'connecting' });
         callbacks.onStatusChange?.('connecting');
         try {
             // Fetch initial chat
@@ -88,8 +88,7 @@ export function createActions(ctx) {
         }
         catch (error) {
             console.error('[AgentSDK] Failed to fetch chat:', error);
-            dispatch({ type: 'SET_STATUS', payload: 'idle' });
-            dispatch({ type: 'SET_IS_GENERATING', payload: false });
+            dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'idle' });
             callbacks.onStatusChange?.('idle');
             return;
         }
@@ -99,27 +98,25 @@ 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);
             },
             onStart: () => {
-                dispatch({ type: 'SET_STATUS', payload: 'streaming' });
+                dispatch({ type: 'SET_CONNECTION_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.
                 if (getStreamManager()) {
                     setStreamManager(undefined);
-                    dispatch({ type: 'SET_STATUS', payload: 'idle' });
-                    dispatch({ type: 'SET_IS_GENERATING', payload: false });
+                    dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'idle' });
                     callbacks.onStatusChange?.('idle');
                 }
             },
@@ -133,7 +130,7 @@ export function createActions(ctx) {
             updateMessage(message);
         });
         setStreamManager(manager);
-        manager.connect();
+        manager.start();
     };
     /** Poll-based alternative to streaming for restricted environments */
     const pollChat = (id) => {
@@ -163,14 +160,13 @@ export function createActions(ctx) {
                 }
             },
             onStart: () => {
-                dispatch({ type: 'SET_STATUS', payload: 'streaming' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'streaming' });
                 callbacks.onStatusChange?.('streaming');
             },
             onStop: () => {
                 if (getStreamManager()) {
                     setStreamManager(undefined);
-                    dispatch({ type: 'SET_STATUS', payload: 'idle' });
-                    dispatch({ type: 'SET_IS_GENERATING', payload: false });
+                    dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'idle' });
                     callbacks.onStatusChange?.('idle');
                 }
             },
@@ -189,8 +185,7 @@ export function createActions(ctx) {
         if (manager) {
             manager.stop();
         }
-        dispatch({ type: 'SET_STATUS', payload: 'idle' });
-        dispatch({ type: 'SET_IS_GENERATING', payload: false });
+        dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'idle' });
         callbacks.onStatusChange?.('idle');
     };
     // =========================================================================
@@ -208,7 +203,7 @@ export function createActions(ctx) {
             if (!trimmedText)
                 return;
             // Update status
-            dispatch({ type: 'SET_STATUS', payload: 'streaming' });
+            dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'streaming' });
             dispatch({ type: 'SET_ERROR', payload: undefined });
             try {
                 const result = await api.sendMessage(client, agentConfig, chatId, trimmedText, files);
@@ -227,15 +222,14 @@ export function createActions(ctx) {
                 }
                 else {
                     // API returned no result — reset status so we don't get stuck
-                    dispatch({ type: 'SET_STATUS', payload: 'idle' });
-                    dispatch({ type: 'SET_IS_GENERATING', payload: false });
+                    dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'idle' });
                     callbacks.onStatusChange?.('idle');
                 }
             }
             catch (error) {
                 console.error('[AgentSDK] Failed to send message:', error);
                 const err = error instanceof Error ? error : new Error('Failed to send message');
-                dispatch({ type: 'SET_STATUS', payload: 'error' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'error' });
                 dispatch({ type: 'SET_ERROR', payload: err.message });
                 callbacks.onError?.(err);
             }
@@ -257,7 +251,7 @@ export function createActions(ctx) {
         },
         clearError: () => {
             dispatch({ type: 'SET_ERROR', payload: undefined });
-            dispatch({ type: 'SET_STATUS', payload: 'idle' });
+            dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'idle' });
         },
         submitToolResult: async (toolInvocationId, result) => {
             try {
@@ -266,7 +260,7 @@ export function createActions(ctx) {
             catch (error) {
                 console.error('[AgentSDK] Failed to submit tool result:', error);
                 const err = error instanceof Error ? error : new Error('Failed to submit tool result');
-                dispatch({ type: 'SET_STATUS', payload: 'error' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'error' });
                 dispatch({ type: 'SET_ERROR', payload: err.message });
                 callbacks.onError?.(err);
                 throw error;
@@ -279,7 +273,7 @@ export function createActions(ctx) {
             catch (error) {
                 console.error('[AgentSDK] Failed to approve tool:', error);
                 const err = error instanceof Error ? error : new Error('Failed to approve tool');
-                dispatch({ type: 'SET_STATUS', payload: 'error' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'error' });
                 dispatch({ type: 'SET_ERROR', payload: err.message });
                 callbacks.onError?.(err);
                 throw error;
@@ -292,7 +286,7 @@ export function createActions(ctx) {
             catch (error) {
                 console.error('[AgentSDK] Failed to reject tool:', error);
                 const err = error instanceof Error ? error : new Error('Failed to reject tool');
-                dispatch({ type: 'SET_STATUS', payload: 'error' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'error' });
                 dispatch({ type: 'SET_ERROR', payload: err.message });
                 callbacks.onError?.(err);
                 throw error;
@@ -310,7 +304,7 @@ export function createActions(ctx) {
             catch (error) {
                 console.error('[AgentSDK] Failed to always-allow tool:', error);
                 const err = error instanceof Error ? error : new Error('Failed to always-allow tool');
-                dispatch({ type: 'SET_STATUS', payload: 'error' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'error' });
                 dispatch({ type: 'SET_ERROR', payload: err.message });
                 callbacks.onError?.(err);
                 throw error;

package/dist/agent/api.d.ts

@@ -5,15 +5,15 @@
  * Uses the client passed in from the provider.
  */
 import type { ChatDTO, ChatMessageDTO } from '../types';
-import type { AdHocAgentConfig, TemplateAgentConfig, AgentOptions, AgentClient, UploadedFile } from './types';
+import type { AdHocAgentConfig, TemplateAgentConfig, AgentOptions, AgentClient, FileRef } from './types';
 /**
  * File input that can be either a File to upload or an already-uploaded file
  */
-export type FileInput = globalThis.File | UploadedFile;
+export type FileInput = globalThis.File | FileRef;
 /**
  * Send a message using ad-hoc agent config
  */
-export declare function sendAdHocMessage(client: AgentClient, config: AdHocAgentConfig, chatId: string | null, text: string, imageUris?: string[], fileUris?: string[]): Promise<{
+export declare function sendAdHocMessage(client: AgentClient, config: AdHocAgentConfig, chatId: string | null, text: string, attachments?: FileRef[]): Promise<{
     chatId: string;
     userMessage: ChatMessageDTO;
     assistantMessage: ChatMessageDTO;
@@ -21,7 +21,7 @@ export declare function sendAdHocMessage(client: AgentClient, config: AdHocAgent
 /**
  * Send a message using template agent config
  */
-export declare function sendTemplateMessage(client: AgentClient, config: TemplateAgentConfig, chatId: string | null, text: string, imageUris?: string[], fileUris?: string[]): Promise<{
+export declare function sendTemplateMessage(client: AgentClient, config: TemplateAgentConfig, chatId: string | null, text: string, attachments?: FileRef[]): Promise<{
     chatId: string;
     userMessage: ChatMessageDTO;
     assistantMessage: ChatMessageDTO;
@@ -67,8 +67,11 @@ export declare function alwaysAllowTool(client: AgentClient, chatId: string, too
 /**
  * Upload a file and return the uploaded file reference
  */
-export declare function uploadFile(client: AgentClient, file: globalThis.File): Promise<UploadedFile>;
+export declare function uploadFile(client: AgentClient, file: globalThis.File): Promise<FileRef>;
 /**
- * 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

@@ -8,13 +8,13 @@ import { isAdHocConfig, extractToolSchemas } from './types';
 /**
  * Check if input is an already-uploaded file
  */
-function isUploadedFile(input) {
+function isFileRef(input) {
     return 'uri' in input && typeof input.uri === 'string';
 }
 /**
  * Send a message using ad-hoc agent config
  */
-export async function sendAdHocMessage(client, config, chatId, text, imageUris, fileUris) {
+export async function sendAdHocMessage(client, config, chatId, text, attachments) {
     // Extract just the schemas from tools (handlers are stripped out)
     const toolSchemas = config.tools ? extractToolSchemas(config.tools) : undefined;
     const request = {
@@ -27,8 +27,7 @@ export async function sendAdHocMessage(client, config, chatId, text, imageUris,
         agent_name: config.name,
         input: {
             text,
-            images: imageUris,
-            files: fileUris,
+            attachments,
             context_size: 0,
             system_prompt: '',
             context: [],
@@ -51,15 +50,14 @@ export async function sendAdHocMessage(client, config, chatId, text, imageUris,
 /**
  * Send a message using template agent config
  */
-export async function sendTemplateMessage(client, config, chatId, text, imageUris, fileUris) {
+export async function sendTemplateMessage(client, config, chatId, text, attachments) {
     const request = {
         chat_id: chatId ?? undefined,
         // Only include agent if it's not empty (for existing chats, backend uses chat's agent)
         agent: config.agent || undefined,
         input: {
             text,
-            images: imageUris,
-            files: fileUris,
+            attachments,
             context_size: 0,
             system_prompt: '',
             context: [],
@@ -83,43 +81,36 @@ export async function sendTemplateMessage(client, config, chatId, text, imageUri
  * Send a message (unified interface)
  */
 export async function sendMessage(client, config, chatId, text, files) {
-    // Process files - upload if needed, or use existing URIs
-    let imageUris;
-    let fileUris;
+    // Process files - upload if needed, collect as FileRef attachments
+    let attachments;
     if (files && files.length > 0) {
-        const uploadedFiles = [];
+        attachments = [];
         for (const file of files) {
-            // Check if already uploaded
-            if (isUploadedFile(file)) {
-                uploadedFiles.push(file);
+            // Check if already uploaded (FileRef)
+            if (isFileRef(file)) {
+                attachments.push(file);
                 continue;
             }
             // Upload the file
             try {
                 const result = await client.files.upload(file);
                 if (result) {
-                    uploadedFiles.push(result);
+                    attachments.push(result);
                 }
             }
             catch (error) {
                 console.error('[AgentSDK] Failed to upload file:', error);
             }
         }
-        // Separate images from other files
-        const images = uploadedFiles.filter(f => f.content_type?.startsWith('image/'));
-        const otherFiles = uploadedFiles.filter(f => !f.content_type?.startsWith('image/'));
-        if (images.length > 0) {
-            imageUris = images.map(f => f.uri);
-        }
-        if (otherFiles.length > 0) {
-            fileUris = otherFiles.map(f => f.uri);
+        if (attachments.length === 0) {
+            attachments = undefined;
         }
     }
     if (isAdHocConfig(config)) {
-        return sendAdHocMessage(client, config, chatId, text, imageUris, fileUris);
+        return sendAdHocMessage(client, config, chatId, text, attachments);
     }
     else {
-        return sendTemplateMessage(client, config, chatId, text, imageUris, fileUris);
+        return sendTemplateMessage(client, config, chatId, text, attachments);
     }
 }
 /**
@@ -204,8 +195,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/hooks.d.ts

@@ -8,13 +8,14 @@ import type { ChatMessageDTO } from '../types';
 /**
  * Hook to access chat state
  *
- * @returns Chat state (messages, status, isGenerating, etc.)
+ * @returns Chat state (chat, messages, connectionStatus, error)
  * @throws Error if used outside AgentChatProvider
  *
  * @example
  * ```tsx
  * function MyComponent() {
- *   const { messages, isGenerating, status } = useAgentChat();
+ *   const { chat, messages } = useAgentChat();
+ *   const isBusy = chat?.status === 'busy';
  *   return <div>{messages.length} messages</div>;
  * }
  * ```
@@ -30,11 +31,12 @@ export declare function useAgentChat(): AgentChatState;
  * ```tsx
  * function SendButton() {
  *   const { sendMessage, stopGeneration } = useAgentActions();
- *   const { isGenerating } = useAgentChat();
+ *   const { chat } = useAgentChat();
+ *   const isBusy = chat?.status === 'busy';
  *
  *   return (
- *     <button onClick={() => isGenerating ? stopGeneration() : sendMessage('Hello!')}>
- *       {isGenerating ? 'Stop' : 'Send'}
+ *     <button onClick={() => isBusy ? stopGeneration() : sendMessage('Hello!')}>
+ *       {isBusy ? 'Stop' : 'Send'}
  *     </button>
  *   );
  * }
@@ -67,11 +69,12 @@ export declare function useMessage(messageId: string): ChatMessageDTO | undefine
  * function ChatInput() {
  *   const { state, actions } = useAgentChatContext();
  *   const [input, setInput] = useState('');
+ *   const isBusy = state.chat?.status === 'busy';
  *
  *   return (
  *     <form onSubmit={() => actions.sendMessage(input)}>
  *       <input value={input} onChange={e => setInput(e.target.value)} />
- *       <button disabled={state.isGenerating}>Send</button>
+ *       <button disabled={isBusy}>Send</button>
  *     </form>
  *   );
  * }

package/dist/agent/hooks.js

@@ -8,13 +8,14 @@ import { AgentChatContext } from './context';
 /**
  * Hook to access chat state
  *
- * @returns Chat state (messages, status, isGenerating, etc.)
+ * @returns Chat state (chat, messages, connectionStatus, error)
  * @throws Error if used outside AgentChatProvider
  *
  * @example
  * ```tsx
  * function MyComponent() {
- *   const { messages, isGenerating, status } = useAgentChat();
+ *   const { chat, messages } = useAgentChat();
+ *   const isBusy = chat?.status === 'busy';
  *   return <div>{messages.length} messages</div>;
  * }
  * ```
@@ -37,11 +38,12 @@ export function useAgentChat() {
  * ```tsx
  * function SendButton() {
  *   const { sendMessage, stopGeneration } = useAgentActions();
- *   const { isGenerating } = useAgentChat();
+ *   const { chat } = useAgentChat();
+ *   const isBusy = chat?.status === 'busy';
  *
  *   return (
- *     <button onClick={() => isGenerating ? stopGeneration() : sendMessage('Hello!')}>
- *       {isGenerating ? 'Stop' : 'Send'}
+ *     <button onClick={() => isBusy ? stopGeneration() : sendMessage('Hello!')}>
+ *       {isBusy ? 'Stop' : 'Send'}
  *     </button>
  *   );
  * }
@@ -84,11 +86,12 @@ export function useMessage(messageId) {
  * function ChatInput() {
  *   const { state, actions } = useAgentChatContext();
  *   const [input, setInput] = useState('');
+ *   const isBusy = state.chat?.status === 'busy';
  *
  *   return (
  *     <form onSubmit={() => actions.sendMessage(input)}>
  *       <input value={input} onChange={e => setInput(e.target.value)} />
- *       <button disabled={state.isGenerating}>Send</button>
+ *       <button disabled={isBusy}>Send</button>
  *     </form>
  *   );
  * }

package/dist/agent/index.d.ts

@@ -29,14 +29,15 @@
  * }
  *
  * function ChatUI() {
- *   const { messages, isGenerating } = useAgentChat();
+ *   const { chat, messages } = useAgentChat();
  *   const { sendMessage, stopGeneration } = useAgentActions();
+ *   const isBusy = chat?.status === 'busy';
  *
  *   return (
  *     <div>
  *       {messages.map(m => <Message key={m.id} message={m} />)}
  *       <input onSubmit={(text) => sendMessage(text)} />
- *       {isGenerating && <button onClick={stopGeneration}>Stop</button>}
+ *       {isBusy && <button onClick={stopGeneration}>Stop</button>}
  *     </div>
  *   );
  * }
@@ -45,5 +46,5 @@
 export { AgentChatProvider } from './provider';
 export { useAgentChat, useAgentActions, useAgentClient, useAgentChatContext, useMessage, } from './hooks';
 export { AgentChatContext, type AgentChatContextValue } from './context';
-export type { AgentClient, UploadedFile, AdHocAgentConfig, TemplateAgentConfig, AgentOptions, AgentChatState, AgentChatActions, ChatStatus, AgentChatProviderProps, ClientTool, ClientToolHandlerFn, } from './types';
+export type { AgentClient, FileRef, AdHocAgentConfig, TemplateAgentConfig, AgentOptions, AgentChatState, AgentChatActions, ChatStatus, AgentChatProviderProps, ClientTool, ClientToolHandlerFn, } from './types';
 export { isAdHocConfig, isTemplateConfig, isClientTool, extractToolSchemas, extractClientToolHandlers, } from './types';

package/dist/agent/index.js

@@ -29,14 +29,15 @@
  * }
  *
  * function ChatUI() {
- *   const { messages, isGenerating } = useAgentChat();
+ *   const { chat, messages } = useAgentChat();
  *   const { sendMessage, stopGeneration } = useAgentActions();
+ *   const isBusy = chat?.status === 'busy';
  *
  *   return (
  *     <div>
  *       {messages.map(m => <Message key={m.id} message={m} />)}
  *       <input onSubmit={(text) => sendMessage(text)} />
- *       {isGenerating && <button onClick={stopGeneration}>Stop</button>}
+ *       {isBusy && <button onClick={stopGeneration}>Stop</button>}
  *     </div>
  *   );
  * }

package/dist/agent/reducer.js

@@ -9,8 +9,7 @@
 export const initialState = {
     chatId: null,
     messages: [],
-    status: 'idle',
-    isGenerating: false,
+    connectionStatus: 'idle',
     error: undefined,
     chat: null,
 };
@@ -24,12 +23,10 @@ export function chatReducer(state, action) {
         case 'SET_CHAT': {
             const chat = action.payload;
             if (!chat) {
-                return { ...state, chat: null, messages: [], isGenerating: false, status: 'idle' };
+                return { ...state, chat: null, messages: [], connectionStatus: 'idle' };
             }
             const messages = [...(chat.chat_messages || [])].sort((a, b) => a.order - b.order);
-            const isGenerating = chat.status === 'busy';
-            const status = isGenerating ? 'streaming' : 'idle';
-            return { ...state, chat, messages, isGenerating, status };
+            return { ...state, chat, messages };
         }
         case 'SET_MESSAGES':
             return { ...state, messages: action.payload };
@@ -51,14 +48,8 @@ export function chatReducer(state, action) {
                 ...state,
                 messages: [...state.messages, action.payload].sort((a, b) => a.order - b.order),
             };
-        case 'SET_STATUS':
-            return {
-                ...state,
-                status: action.payload,
-                isGenerating: action.payload === 'streaming' || action.payload === 'connecting',
-            };
-        case 'SET_IS_GENERATING':
-            return { ...state, isGenerating: action.payload };
+        case 'SET_CONNECTION_STATUS':
+            return { ...state, connectionStatus: action.payload };
         case 'SET_ERROR':
             return { ...state, error: action.payload };
         case 'RESET':

package/dist/agent/types.d.ts

@@ -4,27 +4,21 @@
  * Public types for the Agent chat module.
  */
 import type { Dispatch } from 'react';
-import type { ChatDTO, ChatMessageDTO, AgentTool, AgentConfig as GeneratedAgentConfig, CoreAppConfig } from '../types';
+import type { ChatDTO, ChatMessageDTO, AgentTool, AgentConfig as GeneratedAgentConfig, CoreAppConfig, FileRef } 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)
- */
-export interface UploadedFile {
-    uri: string;
-    content_type?: string;
-}
+export type { FileRef } from '../types';
 /**
  * Minimal client interface required by the agent module.
  * This allows extended clients (like the app client) to be used.
  */
 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>;
+        upload: (data: string | Blob | globalThis.File) => Promise<FileRef>;
     };
 }
 /**
@@ -93,11 +87,9 @@ export interface AgentChatState {
     chatId: string | null;
     /** Chat messages */
     messages: ChatMessageDTO[];
-    /** Chat status */
-    status: ChatStatus;
-    /** Whether the agent is currently generating a response */
-    isGenerating: boolean;
-    /** Error message if status is 'error' */
+    /** Connection status (stream/poll state, not chat.status) */
+    connectionStatus: ChatStatus;
+    /** Error message if connectionStatus is 'error' */
     error?: string;
     /** The full chat object (if loaded) */
     chat: ChatDTO | null;
@@ -107,9 +99,9 @@ export interface AgentChatState {
  */
 export interface AgentChatActions {
     /** Send a message to the agent */
-    sendMessage: (text: string, files?: UploadedFile[]) => Promise<void>;
+    sendMessage: (text: string, files?: FileRef[]) => Promise<void>;
     /** Upload a file and return the uploaded file reference */
-    uploadFile: (file: File) => Promise<UploadedFile>;
+    uploadFile: (file: File) => Promise<FileRef>;
     /** Stop the current generation */
     stopGeneration: () => void;
     /** Reset the chat (start fresh) */
@@ -194,11 +186,8 @@ export type ChatAction = {
     type: 'ADD_MESSAGE';
     payload: ChatMessageDTO;
 } | {
-    type: 'SET_STATUS';
+    type: 'SET_CONNECTION_STATUS';
     payload: ChatStatus;
-} | {
-    type: 'SET_IS_GENERATING';
-    payload: boolean;
 } | {
     type: 'SET_ERROR';
     payload: string | undefined;
@@ -209,7 +198,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/files.js

@@ -81,10 +81,15 @@ export class FilesAPI {
                 contentType = 'application/octet-stream';
             }
         }
+        // Extract filename from File object if not provided in options
+        let filename = options.filename;
+        if (!filename && data instanceof globalThis.File) {
+            filename = data.name;
+        }
         // Step 1: Create the file record
         const fileRequest = {
             uri: '', // Empty URI as it will be set by the server
-            filename: options.filename,
+            filename,
             content_type: contentType,
             path: options.path,
             size: data instanceof Blob ? data.size : undefined,

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/dist/types.d.ts

@@ -509,6 +509,17 @@ export interface CreateFlowRunRequest {
     flow: string;
     input: any;
 }
+/**
+ * CreateAppRequest is the request body for POST /apps
+ */
+export interface CreateAppRequest extends App {
+    /**
+     * PreserveCurrentVersion prevents auto-promoting the new version to current.
+     * Default false = new versions become current (what most users expect).
+     * Set true for admin deployments where you want to test before promoting.
+     */
+    preserve_current_version?: boolean;
+}
 /**
  * CreateAgentRequest is the request body for POST /agents
  * For new agents: omit ID, backend generates it
@@ -596,6 +607,7 @@ export interface DeviceAuthPollResponse {
 export interface DeviceAuthApproveRequest {
     code: string;
     team_id: string;
+    scopes?: string[];
 }
 /**
  * DeviceAuthApproveResponse is returned after approval
@@ -750,6 +762,51 @@ export interface EngineConfig {
      */
     engine_internal_api_url: string;
 }
+/**
+ * ScopeGroup identifies a category of scopes for UI grouping
+ */
+export type ScopeGroup = string;
+export declare const ScopeGroupAgents: ScopeGroup;
+export declare const ScopeGroupApps: ScopeGroup;
+export declare const ScopeGroupConversations: ScopeGroup;
+export declare const ScopeGroupFiles: ScopeGroup;
+export declare const ScopeGroupDatastores: ScopeGroup;
+export declare const ScopeGroupFlows: ScopeGroup;
+export declare const ScopeGroupProjects: ScopeGroup;
+export declare const ScopeGroupTeams: ScopeGroup;
+export declare const ScopeGroupBilling: ScopeGroup;
+export declare const ScopeGroupSecrets: ScopeGroup;
+export declare const ScopeGroupIntegrations: ScopeGroup;
+export declare const ScopeGroupEngines: ScopeGroup;
+export declare const ScopeGroupApiKeys: ScopeGroup;
+export declare const ScopeGroupUser: ScopeGroup;
+export declare const ScopeGroupSettings: ScopeGroup;
+/**
+ * ScopeDefinition describes a single scope for UI rendering
+ */
+export interface ScopeDefinition {
+    value: string;
+    label: string;
+    description: string;
+    group: ScopeGroup;
+}
+/**
+ * ScopeGroupDefinition describes a group of scopes for UI rendering
+ */
+export interface ScopeGroupDefinition {
+    id: ScopeGroup;
+    label: string;
+    description: string;
+}
+/**
+ * ScopePreset represents a predefined bundle of scopes for common use cases
+ */
+export interface ScopePreset {
+    id: string;
+    label: string;
+    description: string;
+    scopes: string[];
+}
 export type AppCategory = string;
 export declare const AppCategoryImage: AppCategory;
 export declare const AppCategoryVideo: AppCategory;
@@ -1042,6 +1099,17 @@ export declare const IntegrationTypeSlack: IntegrationType;
 export declare const IntegrationTypeDiscord: IntegrationType;
 export declare const IntegrationTypeTeams: IntegrationType;
 export declare const IntegrationTypeTelegram: IntegrationType;
+/**
+ * FileRef is a lightweight reference to a file with essential metadata.
+ * Used in chat inputs/context instead of full File objects.
+ */
+export interface FileRef {
+    id?: string;
+    uri: string;
+    filename: string;
+    content_type: string;
+    size?: number;
+}
 export interface ChatMessageContent {
     type: ChatMessageContentType;
     error?: string;
@@ -1078,6 +1146,13 @@ export interface ChatTaskInput {
     role?: ChatMessageRole;
     text?: string;
     reasoning?: string;
+    /**
+     * Attachments is the SDK input field with full file metadata
+     */
+    attachments?: FileRef[];
+    /**
+     * Images and Files are internal fields for task workers (filled from Attachments or context)
+     */
     images?: string[];
     files?: string[];
     tools?: Tool[];

package/dist/types.js

@@ -4,6 +4,21 @@ export const ToolTypeAgent = "agent"; // Sub-agent tools - creates a sub-Chat
 export const ToolTypeHook = "hook"; // Webhook tools - HTTP POST to external URL
 export const ToolTypeClient = "client"; // Client tools - executed by frontend
 export const ToolTypeInternal = "internal"; // Internal/built-in tools (plan, memory, widget, finish)
+export const ScopeGroupAgents = "agents";
+export const ScopeGroupApps = "apps";
+export const ScopeGroupConversations = "conversations";
+export const ScopeGroupFiles = "files";
+export const ScopeGroupDatastores = "datastores";
+export const ScopeGroupFlows = "flows";
+export const ScopeGroupProjects = "projects";
+export const ScopeGroupTeams = "teams";
+export const ScopeGroupBilling = "billing";
+export const ScopeGroupSecrets = "secrets";
+export const ScopeGroupIntegrations = "integrations";
+export const ScopeGroupEngines = "engines";
+export const ScopeGroupApiKeys = "apikeys";
+export const ScopeGroupUser = "user";
+export const ScopeGroupSettings = "settings";
 export const AppCategoryImage = "image";
 export const AppCategoryVideo = "video";
 export const AppCategoryAudio = "audio";

package/package.json

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