@inferencesh/sdk 0.5.9 → 0.5.11

package/dist/api/apps.d.ts

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

package/dist/api/apps.js

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

package/dist/api/files.js

@@ -1,3 +1,42 @@
+/**
+ * Parse a data URI and return the media type and decoded data.
+ *
+ * Supports formats:
+ * - data:image/jpeg;base64,/9j/4AAQ...
+ * - data:text/plain,Hello%20World
+ * - data:;base64,SGVsbG8= (defaults to text/plain)
+ */
+function parseDataUri(uri) {
+    // Match: data:[<mediatype>][;base64],<data>
+    const match = uri.match(/^data:([^;,]*)?(?:;(base64))?,(.*)$/s);
+    if (!match) {
+        throw new Error('Invalid data URI format');
+    }
+    const mediaType = match[1] || 'text/plain';
+    const isBase64 = match[2] === 'base64';
+    let dataStr = match[3];
+    if (isBase64) {
+        // Handle URL-safe base64 (- and _ instead of + and /)
+        dataStr = dataStr.replace(/-/g, '+').replace(/_/g, '/');
+        // Add padding if needed
+        const padding = 4 - (dataStr.length % 4);
+        if (padding !== 4) {
+            dataStr += '='.repeat(padding);
+        }
+        const binaryStr = atob(dataStr);
+        const bytes = new Uint8Array(binaryStr.length);
+        for (let i = 0; i < binaryStr.length; i++) {
+            bytes[i] = binaryStr.charCodeAt(i);
+        }
+        return { mediaType, data: bytes };
+    }
+    else {
+        // URL-encoded data
+        const decoded = decodeURIComponent(dataStr);
+        const encoder = new TextEncoder();
+        return { mediaType, data: encoder.encode(decoded) };
+    }
+}
 /**
  * Files API
  */
@@ -27,11 +66,26 @@ export class FilesAPI {
      * Upload a file (Blob or base64 string)
      */
     async upload(data, options = {}) {
+        // Determine content type
+        let contentType = options.contentType;
+        if (!contentType) {
+            if (data instanceof Blob) {
+                contentType = data.type;
+            }
+            else if (typeof data === 'string' && data.startsWith('data:')) {
+                // Extract media type from data URI
+                const match = data.match(/^data:([^;,]*)?/);
+                contentType = match?.[1] || 'application/octet-stream';
+            }
+            else {
+                contentType = 'application/octet-stream';
+            }
+        }
         // Step 1: Create the file record
         const fileRequest = {
             uri: '', // Empty URI as it will be set by the server
             filename: options.filename,
-            content_type: options.contentType || (data instanceof Blob ? data.type : 'application/octet-stream'),
+            content_type: contentType,
             path: options.path,
             size: data instanceof Blob ? data.size : undefined,
         };
@@ -50,16 +104,8 @@ export class FilesAPI {
         else {
             // If it's a base64 string, convert it to a Blob
             if (data.startsWith('data:')) {
-                const matches = data.match(/^data:([^;]+);base64,(.+)$/);
-                if (!matches) {
-                    throw new Error('Invalid base64 data URI format');
-                }
-                const binaryStr = atob(matches[2]);
-                const bytes = new Uint8Array(binaryStr.length);
-                for (let i = 0; i < binaryStr.length; i++) {
-                    bytes[i] = binaryStr.charCodeAt(i);
-                }
-                contentToUpload = new Blob([bytes], { type: matches[1] });
+                const parsed = parseDataUri(data);
+                contentToUpload = new Blob([parsed.data.buffer], { type: parsed.mediaType });
             }
             else {
                 // Assume it's a clean base64 string
@@ -68,7 +114,7 @@ export class FilesAPI {
                 for (let i = 0; i < binaryStr.length; i++) {
                     bytes[i] = binaryStr.charCodeAt(i);
                 }
-                contentToUpload = new Blob([bytes], { type: options.contentType || 'application/octet-stream' });
+                contentToUpload = new Blob([bytes.buffer], { type: options.contentType || 'application/octet-stream' });
             }
         }
         // Upload to S3 using the signed URL

package/dist/api/tasks.js

@@ -192,7 +192,7 @@ export class TasksAPI {
      * Feature/unfeature a task
      */
     async feature(taskId, featured) {
-        return this.http.request('post', `/tasks/${taskId}/featured`, { data: { featured } });
+        return this.http.request('post', `/tasks/${taskId}/featured`, { data: { is_featured: featured } });
     }
 }
 export function createTasksAPI(http) {

package/dist/http/client.js

@@ -80,7 +80,9 @@ export class HttpClient {
         if (options.params) {
             Object.entries(options.params).forEach(([key, value]) => {
                 if (value !== undefined && value !== null) {
-                    targetUrl.searchParams.append(key, String(value));
+                    // Serialize arrays and objects as JSON, primitives as strings
+                    const serialized = typeof value === 'object' ? JSON.stringify(value) : String(value);
+                    targetUrl.searchParams.append(key, serialized);
                 }
             });
         }

package/dist/http/index.d.ts

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

package/dist/http/index.js

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

package/dist/http/streamable.d.ts

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

package/dist/http/streamable.js

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

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

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