@inferencesh/sdk 0.5.3 → 0.5.5

package/README.md

@@ -264,6 +264,28 @@ await agent.sendMessage('What is the weather in Paris?', {
 });
 ```
 
+### Structured Output
+
+Use `output_schema` to get structured JSON responses:
+
+```typescript
+const agent = client.agents.create({
+  core_app: { ref: 'infsh/claude-sonnet-4@latest' },
+  output_schema: {
+    type: 'object',
+    properties: {
+      summary: { type: 'string' },
+      sentiment: { type: 'string', enum: ['positive', 'negative', 'neutral'] },
+      confidence: { type: 'number' },
+    },
+    required: ['summary', 'sentiment', 'confidence'],
+  },
+  internal_tools: { finish: true },
+});
+
+const response = await agent.sendMessage('Analyze: Great product!');
+```
+
 ### Agent Methods
 
 | Method | Description |

package/dist/agent/actions.js

@@ -6,6 +6,7 @@
  */
 import { ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
 import { StreamManager } from '../http/stream';
+import { PollManager } from '../http/poll';
 import { isAdHocConfig, extractClientToolHandlers } from './types';
 import * as api from './api';
 // =============================================================================
@@ -16,7 +17,7 @@ const dispatchedToolInvocations = new Set();
 // Action Creators
 // =============================================================================
 export function createActions(ctx) {
-    const { client, dispatch, getConfig, getChatId, getClientToolHandlers, getStreamManager, setStreamManager, callbacks } = ctx;
+    const { client, dispatch, getConfig, getChatId, getClientToolHandlers, getStreamManager, setStreamManager, getStreamEnabled, getPollIntervalMs, callbacks } = ctx;
     // =========================================================================
     // Internal helpers
     // =========================================================================
@@ -92,6 +93,11 @@ export function createActions(ctx) {
             callbacks.onStatusChange?.('idle');
             return;
         }
+        if (!getStreamEnabled()) {
+            // Polling mode
+            pollChat(id);
+            return;
+        }
         // Single unified stream with TypedEvents (both Chat and ChatMessage events)
         const manager = new StreamManager({
             createEventSource: () => api.createUnifiedStream(client, id),
@@ -129,6 +135,53 @@ export function createActions(ctx) {
         setStreamManager(manager);
         manager.connect();
     };
+    /** Poll-based alternative to streaming for restricted environments */
+    const pollChat = (id) => {
+        let prevStatus = null;
+        const manager = new PollManager({
+            pollFunction: () => client.http.request('get', `/chats/${id}/status`),
+            intervalMs: getPollIntervalMs(),
+            onData: async (statusData) => {
+                if (statusData.status === prevStatus)
+                    return;
+                prevStatus = statusData.status;
+                // Status changed — fetch full chat
+                try {
+                    const chat = await api.fetchChat(client, id);
+                    if (chat) {
+                        setChat(chat);
+                        if (chat.chat_messages) {
+                            for (const message of chat.chat_messages) {
+                                updateMessage(message);
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    console.warn('[AgentSDK] Poll fetch error:', err);
+                    callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+                }
+            },
+            onStart: () => {
+                dispatch({ type: 'SET_STATUS', payload: 'streaming' });
+                callbacks.onStatusChange?.('streaming');
+            },
+            onStop: () => {
+                if (getStreamManager()) {
+                    setStreamManager(undefined);
+                    dispatch({ type: 'SET_STATUS', payload: 'idle' });
+                    dispatch({ type: 'SET_IS_GENERATING', payload: false });
+                    callbacks.onStatusChange?.('idle');
+                }
+            },
+            onError: (error) => {
+                console.warn('[AgentSDK] Poll error:', error);
+                callbacks.onError?.(error);
+            },
+        });
+        setStreamManager(manager);
+        manager.start();
+    };
     const stopStream = () => {
         const manager = getStreamManager();
         // Clear ref first so onStop callback (from manager.stop) is a no-op

package/dist/agent/provider.d.ts

@@ -27,7 +27,7 @@ import type { AgentChatProviderProps } from './types';
  * }
  * ```
  */
-export declare function AgentChatProvider({ client, agentConfig, chatId, clientToolHandlers: extraHandlers, onChatCreated, onStatusChange, onError, children, }: AgentChatProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function AgentChatProvider({ client, agentConfig, chatId, clientToolHandlers: extraHandlers, onChatCreated, onStatusChange, onError, stream, pollIntervalMs, children, }: AgentChatProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace AgentChatProvider {
     var displayName: string;
 }

package/dist/agent/provider.js

@@ -39,13 +39,15 @@ function mergeHandlers(base, extra) {
  * }
  * ```
  */
-export function AgentChatProvider({ client, agentConfig, chatId, clientToolHandlers: extraHandlers, onChatCreated, onStatusChange, onError, children, }) {
+export function AgentChatProvider({ client, agentConfig, chatId, clientToolHandlers: extraHandlers, onChatCreated, onStatusChange, onError, stream, pollIntervalMs, children, }) {
     // Core state via useReducer
     const [state, dispatch] = useReducer(chatReducer, initialState);
     // Refs for mutable values that actions need access to
     const configRef = useRef(agentConfig);
     const chatIdRef = useRef(chatId ?? null);
     const streamManagerRef = useRef(undefined);
+    const streamRef = useRef(stream);
+    const pollIntervalMsRef = useRef(pollIntervalMs);
     const clientToolHandlersRef = useRef(mergeHandlers(getClientToolHandlers(agentConfig), extraHandlers));
     const callbacksRef = useRef({ onChatCreated, onStatusChange, onError });
     // Keep refs in sync with props
@@ -56,6 +58,10 @@ export function AgentChatProvider({ client, agentConfig, chatId, clientToolHandl
     useEffect(() => {
         callbacksRef.current = { onChatCreated, onStatusChange, onError };
     }, [onChatCreated, onStatusChange, onError]);
+    useEffect(() => {
+        streamRef.current = stream;
+        pollIntervalMsRef.current = pollIntervalMs;
+    }, [stream, pollIntervalMs]);
     // Keep chatIdRef synced with state
     useEffect(() => {
         chatIdRef.current = state.chatId;
@@ -69,6 +75,8 @@ export function AgentChatProvider({ client, agentConfig, chatId, clientToolHandl
         getClientToolHandlers: () => clientToolHandlersRef.current,
         getStreamManager: () => streamManagerRef.current,
         setStreamManager: (manager) => { streamManagerRef.current = manager; },
+        getStreamEnabled: () => streamRef.current ?? client.http.getStreamDefault(),
+        getPollIntervalMs: () => pollIntervalMsRef.current ?? client.http.getPollIntervalMs(),
         callbacks: callbacksRef.current,
     }), [client]);
     // Re-bind callbacks when they change

package/dist/agent/types.d.ts

@@ -7,6 +7,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 { PollManager } from '../http/poll';
 /**
  * Minimal file interface returned by upload (just needs uri and content_type)
  */
@@ -20,7 +21,7 @@ export interface UploadedFile {
  */
 export interface AgentClient {
     /** HTTP client for API requests */
-    http: Pick<HttpClient, 'request' | 'createEventSource'>;
+    http: Pick<HttpClient, 'request' | 'createEventSource' | 'getStreamDefault' | 'getPollIntervalMs'>;
     /** Files API for uploads */
     files: {
         upload: (data: string | Blob | globalThis.File) => Promise<UploadedFile>;
@@ -142,6 +143,10 @@ export interface AgentChatProviderProps {
     onStatusChange?: (status: ChatStatus) => void;
     /** Callback when an error occurs */
     onError?: (error: Error) => void;
+    /** Use SSE streaming (true, default) or polling (false) for real-time updates */
+    stream?: boolean;
+    /** Polling interval in ms when stream is false (default: 2000) */
+    pollIntervalMs?: number;
     /** Children */
     children: React.ReactNode;
 }
@@ -203,14 +208,18 @@ export type ChatAction = {
 /**
  * Context for action creators
  */
+/** Union of manager types used for real-time updates */
+export type UpdateManager = StreamManager<unknown> | PollManager<unknown>;
 export interface ActionsContext {
     client: AgentClient;
     dispatch: Dispatch<ChatAction>;
     getConfig: () => AgentOptions | null;
     getChatId: () => string | null;
     getClientToolHandlers: () => Map<string, ClientToolHandlerFn>;
-    getStreamManager: () => StreamManager<unknown> | undefined;
-    setStreamManager: (manager: StreamManager<unknown> | undefined) => void;
+    getStreamManager: () => UpdateManager | undefined;
+    setStreamManager: (manager: UpdateManager | undefined) => void;
+    getStreamEnabled: () => boolean;
+    getPollIntervalMs: () => number;
     callbacks: {
         onChatCreated?: (chatId: string) => void;
         onStatusChange?: (status: ChatStatus) => void;

package/dist/api/agents.d.ts

@@ -27,6 +27,10 @@ export interface SendMessageOptions {
         name: string;
         args: Record<string, unknown>;
     }) => void;
+    /** Use SSE streaming (true) or polling (false). Overrides client default. */
+    stream?: boolean;
+    /** Polling interval in ms when stream is false. Overrides client default. */
+    pollIntervalMs?: number;
 }
 /**
  * Agent for chat interactions
@@ -40,6 +44,7 @@ export declare class Agent {
     private readonly agentName;
     private chatId;
     private stream;
+    private poller;
     private dispatchedToolCalls;
     /** @internal */
     constructor(http: HttpClient, files: FilesAPI, config: string | AgentConfig, options?: AgentOptions);
@@ -64,7 +69,7 @@ export declare class Agent {
         };
         form_data?: Record<string, unknown>;
     }): Promise<void>;
-    /** Stop streaming and cleanup */
+    /** Stop streaming/polling and cleanup */
     disconnect(): void;
     /** Reset the agent (start fresh chat) */
     reset(): void;
@@ -74,6 +79,8 @@ export declare class Agent {
     startStreaming(options?: Omit<SendMessageOptions, 'files'>): void;
     /** Stream events until chat becomes idle */
     private streamUntilIdle;
+    /** Poll until chat becomes idle, dispatching callbacks on changes */
+    private pollUntilIdle;
 }
 /**
  * Agents API

package/dist/api/agents.js

@@ -1,4 +1,5 @@
 import { StreamManager } from '../http/stream';
+import { PollManager } from '../http/poll';
 import { ToolTypeClient, ToolInvocationStatusAwaitingInput, } from '../types';
 /**
  * Agent for chat interactions
@@ -10,6 +11,7 @@ export class Agent {
     constructor(http, files, config, options) {
         this.chatId = null;
         this.stream = null;
+        this.poller = null;
         this.dispatchedToolCalls = new Set();
         this.http = http;
         this.files = files;
@@ -59,24 +61,28 @@ export class Agent {
                 agent_name: this.agentName ?? this.config.name,
                 input: { text, images: imageUris, files: fileUris, role: 'user', context: [], system_prompt: '', context_size: 0 },
             };
-        // For existing chats with callbacks: Start streaming BEFORE POST so we don't miss updates
-        let streamPromise = null;
+        const useStream = options.stream ?? this.http.getStreamDefault();
+        const waitFn = useStream
+            ? (opts) => this.streamUntilIdle(opts)
+            : (opts) => this.pollUntilIdle(opts);
+        // For existing chats with callbacks: Start waiting BEFORE POST so we don't miss updates
+        let waitPromise = null;
         if (this.chatId && hasCallbacks) {
-            streamPromise = this.streamUntilIdle(options);
+            waitPromise = waitFn(options);
         }
         // Make the POST request
         const response = await this.http.request('post', '/agents/run', { data: body });
-        // For new chats: Set chatId and start streaming immediately after POST
+        // For new chats: Set chatId and start waiting immediately after POST
         const isNewChat = !this.chatId && response.assistant_message.chat_id;
         if (isNewChat) {
             this.chatId = response.assistant_message.chat_id;
             if (hasCallbacks) {
-                streamPromise = this.streamUntilIdle(options);
+                waitPromise = waitFn(options);
             }
         }
-        // Wait for streaming to complete
-        if (streamPromise) {
-            await streamPromise;
+        // Wait for completion
+        if (waitPromise) {
+            await waitPromise;
         }
         return { userMessage: response.user_message, assistantMessage: response.assistant_message };
     }
@@ -100,10 +106,12 @@ export class Agent {
         const result = typeof resultOrAction === 'string' ? resultOrAction : JSON.stringify(resultOrAction);
         await this.http.request('post', `/tools/${toolInvocationId}`, { data: { result } });
     }
-    /** Stop streaming and cleanup */
+    /** Stop streaming/polling and cleanup */
     disconnect() {
         this.stream?.stop();
         this.stream = null;
+        this.poller?.stop();
+        this.poller = null;
     }
     /** Reset the agent (start fresh chat) */
     reset() {
@@ -155,6 +163,73 @@ export class Agent {
             this.stream.connect();
         });
     }
+    /** Poll until chat becomes idle, dispatching callbacks on changes */
+    pollUntilIdle(options) {
+        if (!this.chatId)
+            return Promise.resolve();
+        const intervalMs = options.pollIntervalMs ?? this.http.getPollIntervalMs();
+        let prevStatus = null;
+        let knownMessageIds = new Set();
+        return new Promise((resolve) => {
+            this.poller?.stop();
+            this.poller = new PollManager({
+                pollFunction: async () => {
+                    // Lightweight status check first
+                    const status = await this.http.request('get', `/chats/${this.chatId}/status`);
+                    if (status.status === prevStatus) {
+                        // No change — return a stub to skip processing
+                        return { status: status.status };
+                    }
+                    // Status changed — fetch full chat
+                    return this.http.request('get', `/chats/${this.chatId}`);
+                },
+                intervalMs,
+                onData: (chat) => {
+                    if (chat.status === prevStatus && !chat.chat_messages)
+                        return;
+                    prevStatus = chat.status;
+                    options.onChat?.(chat);
+                    // Dispatch new/updated messages
+                    if (chat.chat_messages && options.onMessage) {
+                        for (const message of chat.chat_messages) {
+                            if (!knownMessageIds.has(message.id)) {
+                                knownMessageIds.add(message.id);
+                                options.onMessage(message);
+                            }
+                            else {
+                                // Re-dispatch for potential updates
+                                options.onMessage(message);
+                            }
+                            // Handle client tool invocations
+                            if (message.tool_invocations && options.onToolCall) {
+                                for (const inv of message.tool_invocations) {
+                                    if (this.dispatchedToolCalls.has(inv.id))
+                                        continue;
+                                    if (inv.type === ToolTypeClient && inv.status === ToolInvocationStatusAwaitingInput) {
+                                        this.dispatchedToolCalls.add(inv.id);
+                                        options.onToolCall({
+                                            id: inv.id,
+                                            name: inv.function?.name || '',
+                                            args: inv.function?.arguments || {},
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (chat.status === 'idle') {
+                        this.poller?.stop();
+                        this.poller = null;
+                        resolve();
+                    }
+                },
+                onError: (error) => {
+                    console.warn('[Agent] Poll error:', error);
+                },
+            });
+            this.poller.start();
+        });
+    }
 }
 /**
  * Agents API

package/dist/api/tasks.d.ts

@@ -13,6 +13,10 @@ export interface RunOptions {
     maxReconnects?: number;
     /** Delay between reconnection attempts in ms (default: 1000) */
     reconnectDelayMs?: number;
+    /** Use SSE streaming (true) or polling (false). Overrides client default. */
+    stream?: boolean;
+    /** Polling interval in ms when stream is false. Overrides client default. */
+    pollIntervalMs?: number;
 }
 /**
  * Tasks API
@@ -52,6 +56,8 @@ export declare class TasksAPI {
      * Run a task and optionally wait for completion
      */
     run(params: ApiAppRunRequest, processedInput: unknown, options?: RunOptions): Promise<Task>;
+    /** Poll GET /tasks/{id}/status until terminal, full-fetch on status change. */
+    private pollUntilTerminal;
     /**
      * Update task visibility
      */

package/dist/api/tasks.js

@@ -1,4 +1,5 @@
 import { StreamManager } from '../http/stream';
+import { PollManager } from '../http/poll';
 import { TaskStatusCompleted, TaskStatusFailed, TaskStatusCancelled, } from '../types';
 //TODO: This is ugly...
 function stripTask(task) {
@@ -78,7 +79,11 @@ export class TasksAPI {
         if (!wait) {
             return stripTask(task);
         }
-        // Wait for completion with optional updates
+        const useStream = options.stream ?? this.http.getStreamDefault();
+        if (!useStream) {
+            return this.pollUntilTerminal(task, options);
+        }
+        // Wait for completion with optional updates via SSE
         // Accumulate state across partial updates to preserve fields like session_id
         let accumulatedTask = { ...task };
         return new Promise((resolve, reject) => {
@@ -131,6 +136,51 @@ export class TasksAPI {
             streamManager.connect();
         });
     }
+    /** Poll GET /tasks/{id}/status until terminal, full-fetch on status change. */
+    pollUntilTerminal(task, options) {
+        const { onUpdate, maxReconnects = 5 } = options;
+        const intervalMs = options.pollIntervalMs ?? this.http.getPollIntervalMs();
+        let prevStatus = task.status;
+        return new Promise((resolve, reject) => {
+            const poller = new PollManager({
+                pollFunction: () => this.http.request('get', `/tasks/${task.id}/status`),
+                intervalMs,
+                maxRetries: maxReconnects,
+                onData: async (statusData) => {
+                    if (statusData.status === prevStatus)
+                        return;
+                    prevStatus = statusData.status;
+                    // Status changed — fetch full task
+                    try {
+                        const fullTask = await this.http.request('get', `/tasks/${task.id}`);
+                        const stripped = stripTask(fullTask);
+                        onUpdate?.(stripped);
+                        if (fullTask.status === TaskStatusCompleted) {
+                            poller.stop();
+                            resolve(stripped);
+                        }
+                        else if (fullTask.status === TaskStatusFailed) {
+                            poller.stop();
+                            reject(new Error(fullTask.error || 'task failed'));
+                        }
+                        else if (fullTask.status === TaskStatusCancelled) {
+                            poller.stop();
+                            reject(new Error('task cancelled'));
+                        }
+                    }
+                    catch (err) {
+                        poller.stop();
+                        reject(err instanceof Error ? err : new Error(String(err)));
+                    }
+                },
+                onError: (error) => {
+                    reject(error);
+                    poller.stop();
+                },
+            });
+            poller.start();
+        });
+    }
     /**
      * Update task visibility
      */

package/dist/http/client.d.ts

@@ -25,6 +25,16 @@ export interface HttpClientConfig {
      * Can be used for retry logic, auth refresh, OTP handling, etc.
      */
     onError?: ErrorHandler;
+    /**
+     * Use polling instead of SSE for real-time updates (default: true = SSE).
+     * Set to false for environments that can't maintain long-lived connections
+     * (Convex actions, Cloudflare Workers, restricted edge runtimes).
+     */
+    stream?: boolean;
+    /**
+     * Polling interval in milliseconds when stream is false (default: 2000).
+     */
+    pollIntervalMs?: number;
 }
 /**
  * Low-level HTTP client for inference.sh API
@@ -40,9 +50,15 @@ export declare class HttpClient {
     private readonly customHeaders;
     private readonly credentials;
     private readonly onError;
+    private readonly streamDefault;
+    private readonly pollInterval;
     constructor(config: HttpClientConfig);
     /** Get the base URL */
     getBaseUrl(): string;
+    /** Whether SSE streaming is the default transport (true) or polling (false) */
+    getStreamDefault(): boolean;
+    /** Get the default poll interval in ms */
+    getPollIntervalMs(): number;
     /** Check if in proxy mode */
     isProxyMode(): boolean;
     /** Resolve dynamic headers */

package/dist/http/client.js

@@ -19,11 +19,21 @@ export class HttpClient {
         this.customHeaders = config.headers || {};
         this.credentials = config.credentials || 'include';
         this.onError = config.onError;
+        this.streamDefault = config.stream ?? true;
+        this.pollInterval = config.pollIntervalMs ?? 2000;
     }
     /** Get the base URL */
     getBaseUrl() {
         return this.baseUrl;
     }
+    /** Whether SSE streaming is the default transport (true) or polling (false) */
+    getStreamDefault() {
+        return this.streamDefault;
+    }
+    /** Get the default poll interval in ms */
+    getPollIntervalMs() {
+        return this.pollInterval;
+    }
     /** Check if in proxy mode */
     isProxyMode() {
         return !!this.proxyUrl;

package/dist/http/poll.d.ts

@@ -0,0 +1,39 @@
+/**
+ * PollManager — polling transport alternative to StreamManager.
+ *
+ * Used when long-lived SSE connections are unavailable (Convex actions,
+ * Cloudflare Workers, restricted edge runtimes).
+ */
+export interface PollManagerOptions<T> {
+    /** Function that fetches the latest data each poll cycle */
+    pollFunction: () => Promise<T>;
+    /** Milliseconds between polls (default 2000) */
+    intervalMs?: number;
+    /** Maximum consecutive errors before giving up (default 5) */
+    maxRetries?: number;
+    /** Delay after an error before retrying (default 1000) */
+    retryDelayMs?: number;
+    /** Called with data on every successful poll */
+    onData?: (data: T) => void;
+    /** Called when an error occurs */
+    onError?: (error: Error) => void;
+    /** Called when polling starts */
+    onStart?: () => void;
+    /** Called when polling stops (intentionally or after max retries) */
+    onStop?: () => void;
+}
+export declare class PollManager<T> {
+    private options;
+    private interval;
+    private retryTimeout;
+    private consecutiveErrors;
+    private isStopped;
+    private polling;
+    constructor(options: PollManagerOptions<T>);
+    /** Start polling. First poll is immediate, then at intervalMs. */
+    start(): void;
+    /** Stop polling and clean up. */
+    stop(): void;
+    private cleanup;
+    private poll;
+}

package/dist/http/poll.js

@@ -0,0 +1,73 @@
+/**
+ * PollManager — polling transport alternative to StreamManager.
+ *
+ * Used when long-lived SSE connections are unavailable (Convex actions,
+ * Cloudflare Workers, restricted edge runtimes).
+ */
+export class PollManager {
+    constructor(options) {
+        this.interval = null;
+        this.retryTimeout = null;
+        this.consecutiveErrors = 0;
+        this.isStopped = true;
+        this.polling = false;
+        this.options = {
+            intervalMs: 2000,
+            maxRetries: 5,
+            retryDelayMs: 1000,
+            ...options,
+        };
+    }
+    /** Start polling. First poll is immediate, then at intervalMs. */
+    start() {
+        if (!this.isStopped)
+            return;
+        this.isStopped = false;
+        this.consecutiveErrors = 0;
+        this.options.onStart?.();
+        this.poll(); // immediate first poll
+        this.interval = setInterval(() => this.poll(), this.options.intervalMs);
+    }
+    /** Stop polling and clean up. */
+    stop() {
+        if (this.isStopped)
+            return;
+        this.isStopped = true;
+        this.cleanup();
+        this.options.onStop?.();
+    }
+    cleanup() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        if (this.retryTimeout) {
+            clearTimeout(this.retryTimeout);
+            this.retryTimeout = null;
+        }
+    }
+    async poll() {
+        if (this.isStopped || this.polling)
+            return;
+        this.polling = true;
+        try {
+            const data = await this.options.pollFunction();
+            this.polling = false;
+            if (this.isStopped)
+                return;
+            this.consecutiveErrors = 0;
+            this.options.onData?.(data);
+        }
+        catch (err) {
+            this.polling = false;
+            if (this.isStopped)
+                return;
+            const error = err instanceof Error ? err : new Error(String(err));
+            this.consecutiveErrors++;
+            this.options.onError?.(error);
+            if (this.consecutiveErrors >= this.options.maxRetries) {
+                this.stop();
+            }
+        }
+    }
+}

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 { PollManager, PollManagerOptions } from './http/poll';
 export { InferenceError, RequirementsNotMetException, SessionError, SessionNotFoundError, SessionExpiredError, SessionEndedError, WorkerLostError, } from './http/errors';
 export { TasksAPI, RunOptions } from './api/tasks';
 export { FilesAPI, UploadFileOptions } from './api/files';
@@ -35,6 +36,15 @@ export interface InferenceConfig {
      * When set, requests are routed through your proxy server to protect API keys.
      */
     proxyUrl?: string;
+    /**
+     * Use SSE streaming (true, default) or polling (false) for real-time updates.
+     * Set to false for environments that can't maintain long-lived connections.
+     */
+    stream?: boolean;
+    /**
+     * Polling interval in milliseconds when stream is false (default: 2000).
+     */
+    pollIntervalMs?: number;
 }
 /**
  * Inference.sh SDK Client

package/dist/index.js

@@ -1,6 +1,7 @@
 // HTTP utilities
 export { HttpClient, createHttpClient } from './http/client';
 export { StreamManager } from './http/stream';
+export { PollManager } from './http/poll';
 export { InferenceError, RequirementsNotMetException, SessionError, SessionNotFoundError, SessionExpiredError, SessionEndedError, WorkerLostError, } from './http/errors';
 // API modules
 export { TasksAPI } from './api/tasks';
@@ -49,6 +50,8 @@ export class Inference {
             headers: 'headers' in config ? config.headers : undefined,
             credentials: 'credentials' in config ? config.credentials : undefined,
             onError: 'onError' in config ? config.onError : undefined,
+            stream: 'stream' in config ? config.stream : undefined,
+            pollIntervalMs: 'pollIntervalMs' in config ? config.pollIntervalMs : undefined,
         });
         this.files = new FilesAPI(this.http);
         this.tasks = new TasksAPI(this.http);

package/dist/tool-builder.js

@@ -28,6 +28,8 @@ function toJsonSchema(params) {
         if (schema.properties) {
             const nested = toJsonSchema(schema.properties);
             prop.properties = nested.properties;
+            if (nested.required.length > 0)
+                prop.required = nested.required;
         }
         if (schema.items) {
             const itemSchema = toJsonSchema({ _item: schema.items });

package/dist/tool-builder.test.js

@@ -149,8 +149,19 @@ describe('ClientToolBuilder (tool)', () => {
                 name: { type: 'string', description: 'Name' },
                 email: { type: 'string', description: 'Email' },
             },
+            required: ['name', 'email'],
         });
     });
+    it('propagates required into nested objects with optional fields', () => {
+        const t = tool('update_user')
+            .param('user', object({
+            name: string('Name'),
+            bio: optional(string('Bio')),
+        }))
+            .build();
+        const userProp = t.client?.input_schema.properties?.user;
+        expect(userProp.required).toEqual(['name']);
+    });
     it('creates tool with array parameters', () => {
         const t = tool('process_items')
             .param('items', array(string('Item'), 'List of items'))

package/dist/types.d.ts

@@ -946,6 +946,14 @@ export interface PermissionModelDTO {
     team?: TeamRelationDTO;
     visibility: Visibility;
 }
+/**
+ * ResourceStatusDTO is a lightweight status-only response for polling transports.
+ */
+export interface ResourceStatusDTO {
+    id: string;
+    status: any;
+    updated_at: string;
+}
 export type ChatStatus = string;
 export declare const ChatStatusBusy: ChatStatus;
 export declare const ChatStatusIdle: ChatStatus;

package/package.json

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