@yetter/client 0.0.10 → 0.0.12

package/dist/client.js

@@ -32,7 +32,7 @@ export class yetter {
         let lastStatusResponse;
         const startTime = Date.now();
         const timeoutMilliseconds = 30 * 60 * 1000; // 30 minutes
-        while (status !== "COMPLETED" && status !== "FAILED") {
+        while (status !== "COMPLETED" && status !== "ERROR" && status !== "CANCELLED") {
             if (Date.now() - startTime > timeoutMilliseconds) {
                 console.warn(`Subscription timed out after 30 minutes for request ID: ${generateResponse.request_id}. Attempting to cancel.`);
                 try {
@@ -59,10 +59,13 @@ export class yetter {
                 throw error;
             }
         }
-        if (status === "FAILED") {
+        if (status === "ERROR") {
             const errorMessage = ((_b = lastStatusResponse === null || lastStatusResponse === void 0 ? void 0 : lastStatusResponse.logs) === null || _b === void 0 ? void 0 : _b.map(log => log.message).join("\n")) || "Image generation failed.";
             throw new Error(errorMessage);
         }
+        else if (status === "CANCELLED") {
+            throw new Error("Image generation was cancelled by user.");
+        }
         const finalResponse = await client.getResponse({
             url: generateResponse.response_url,
         });
@@ -80,13 +83,11 @@ export class yetter {
             model: model,
             ...options.input,
         });
-        console.timeEnd("Initial API Response");
         const requestId = initialApiResponse.request_id;
         const responseUrl = initialApiResponse.response_url;
         const cancelUrl = initialApiResponse.cancel_url;
         const sseStreamUrl = `${client.getApiEndpoint()}/${model}/requests/${requestId}/status/stream`;
         let eventSource;
-        let streamEnded = false;
         // Setup the promise for the done() method
         let resolveDonePromise;
         let rejectDonePromise;
@@ -100,8 +101,21 @@ export class yetter {
             events: [],
             resolvers: [],
             isClosed: false,
+            isSettled: false,
+            currentStatus: "",
+            callResolver(value) {
+                if (this.isSettled)
+                    return;
+                this.isSettled = true;
+                resolveDonePromise(value);
+            },
+            callRejecter(reason) {
+                if (this.isSettled)
+                    return;
+                this.isSettled = true;
+                rejectDonePromise(reason);
+            },
             push(event) {
-                var _b;
                 if (this.isClosed)
                     return;
                 if (this.resolvers.length > 0) {
@@ -111,53 +125,43 @@ export class yetter {
                     this.events.push(event);
                 }
                 // Check for terminal events to resolve/reject the donePromise
-                if (event.status === "COMPLETED") {
-                    streamEnded = true;
-                    client.getResponse({ url: responseUrl })
-                        .then(resolveDonePromise)
-                        .catch(rejectDonePromise)
-                        .finally(() => this.close());
-                }
-                else if (event.status === "FAILED") {
-                    streamEnded = true;
-                    rejectDonePromise(new Error(((_b = event.logs) === null || _b === void 0 ? void 0 : _b.map(l => l.message).join('\n')) || `Stream reported FAILED for ${requestId}`));
-                    this.close();
-                }
+                this.currentStatus = event.status;
             },
             error(err) {
                 if (this.isClosed)
                     return;
-                // If streamEnded is true, it means a terminal event (COMPLETED/FAILED)
-                // has already been processed and is handling the donePromise.
-                // This error is likely a secondary effect of the connection closing.
-                if (!streamEnded) {
-                    rejectDonePromise(err); // Only reject if no terminal event was processed
+                if (this.resolvers.length > 0) {
+                    this.resolvers.shift()({ value: undefined, done: true });
                 }
-                else {
-                    console.warn("SSE 'onerror' event after stream was considered ended (COMPLETED/FAILED). This error will not alter the done() promise.", err);
+                this._close();
+                const errorToReport = err instanceof Error ? err : new Error("Stream closed prematurely or unexpectedly.");
+                this.callRejecter(errorToReport);
+            },
+            done(value) {
+                if (this.isClosed)
+                    return;
+                if (this.resolvers.length > 0) {
+                    this.resolvers.shift()({ value: undefined, done: true });
                 }
-                streamEnded = true; // Ensure it's marked as ended
+                this._close();
+                this.callResolver(value);
+            },
+            cancel() {
+                if (this.isClosed)
+                    return;
                 if (this.resolvers.length > 0) {
-                    this.resolvers.shift()({ value: undefined, done: true }); // Signal error to iterator consumer
+                    this.resolvers.shift()({ value: undefined, done: true });
                 }
-                this.close(); // Proceed to close EventSource etc.
+                this._close();
+                this.callRejecter(new Error("Stream was cancelled by user."));
             },
-            close() {
+            _close() {
                 if (this.isClosed)
                     return;
                 this.isClosed = true;
                 this.resolvers.forEach(resolve => resolve({ value: undefined, done: true }));
                 this.resolvers = [];
                 eventSource === null || eventSource === void 0 ? void 0 : eventSource.close();
-                // If donePromise is still pending, reject it as stream closed prematurely
-                // Use a timeout to allow any final event processing for COMPLETED/FAILED to settle it first
-                setTimeout(() => {
-                    donePromise.catch(() => { }).finally(() => {
-                        if (!streamEnded) { // If not explicitly completed or failed
-                            rejectDonePromise(new Error("Stream closed prematurely or unexpectedly."));
-                        }
-                    });
-                }, 100);
             },
             next() {
                 if (this.events.length > 0) {
@@ -171,7 +175,6 @@ export class yetter {
         };
         eventSource = new EventSourcePolyfill(sseStreamUrl, {
             headers: { 'Authorization': `${_a.apiKey}` },
-            heartbeatTimeout: 3000,
         });
         eventSource.onopen = (event) => {
             console.log("SSE Connection Opened:", event);
@@ -187,9 +190,36 @@ export class yetter {
                 controller.error(new Error(`Error parsing SSE 'data' event: ${e.message}`));
             }
         });
-        eventSource.addEventListener('done', (event) => {
+        // when 'done' event is received, currentStatus can only be COMPLETED or CANCELLED
+        // TODO: remove currentStatus and branch two cases(COMPLETED and CANCELLED) by response status by responseUrl
+        // TODO: Determine whether raise error or not when response status is CANCELLED
+        //  => current code raise error when response status is CANCELLED because resolveDonePromise only get completed response
+        // => this mean that user expect only completed response from .done() method
+        eventSource.addEventListener('done', async (event) => {
             // console.log("SSE 'done' event received, raw data:", event.data);
-            controller.close();
+            try {
+                if (controller.currentStatus === "COMPLETED") {
+                    // Close SSE immediately to avoid any late 'error' events during await
+                    try {
+                        eventSource === null || eventSource === void 0 ? void 0 : eventSource.close();
+                    }
+                    catch { }
+                    const response = await client.getResponse({ url: responseUrl });
+                    controller.done(response);
+                }
+                else if (controller.currentStatus === "CANCELLED") {
+                    controller.cancel();
+                }
+            }
+            catch (e) {
+                console.error("Error parsing SSE 'done' event:", e, "Raw data:", event.data);
+                controller.error(new Error(`Error parsing SSE 'done' event: ${e.message}`));
+            }
+        });
+        eventSource.addEventListener('error', (event) => {
+            // console.log("SSE 'done' event received, raw data:", event.data);
+            console.log("SSE 'error' event received, raw data:", event.data);
+            controller.error(new Error("Stream reported ERROR for ${requestId}"));
         });
         eventSource.onerror = (err) => {
             var _b;
@@ -205,7 +235,7 @@ export class yetter {
         if (initialApiResponse.status === "COMPLETED") {
             controller.push(initialApiResponse);
         }
-        else if (initialApiResponse.status === "FAILED") {
+        else if (initialApiResponse.status === "ERROR") {
             controller.push(initialApiResponse);
         }
         return {
@@ -219,7 +249,6 @@ export class yetter {
             },
             done: () => donePromise,
             cancel: async () => {
-                controller.close();
                 try {
                     await client.cancel({ url: cancelUrl });
                     console.log(`Stream for ${requestId} - underlying request cancelled.`);
@@ -227,14 +256,237 @@ export class yetter {
                 catch (e) {
                     console.error(`Error cancelling underlying request for stream ${requestId}:`, e.message);
                 }
-                // Ensure donePromise is settled if not already
-                if (!streamEnded) {
-                    rejectDonePromise(new Error("Stream was cancelled by user."));
-                }
             },
             getRequestId: () => requestId,
         };
     }
+    /**
+     * Upload a file from the filesystem (Node.js) or File/Blob object (browser)
+     *
+     * @param fileOrPath File path (Node.js) or File/Blob object (browser)
+     * @param options Upload configuration options
+     * @returns Promise resolving to upload result with public URL
+     *
+     * @example
+     * ```typescript
+     * // Node.js
+     * const result = await yetter.uploadFile("/path/to/image.jpg", {
+     *   onProgress: (pct) => console.log(`Upload: ${pct}%`)
+     * });
+     *
+     * // Browser
+     * const fileInput = document.querySelector('input[type="file"]');
+     * const file = fileInput.files[0];
+     * const result = await yetter.uploadFile(file, {
+     *   onProgress: (pct) => updateProgressBar(pct)
+     * });
+     * ```
+     */
+    static async uploadFile(fileOrPath, options = {}) {
+        if (!_a.apiKey) {
+            throw new Error("API key is not configured. Call yetter.configure()");
+        }
+        if (typeof fileOrPath === 'string') {
+            // Node.js path
+            return _a._uploadFromPath(fileOrPath, options);
+        }
+        else {
+            // Browser File/Blob
+            return _a._uploadFromBlob(fileOrPath, options);
+        }
+    }
+    /**
+     * Upload a file from browser (File or Blob object)
+     * This is an alias for uploadFile for better clarity in browser contexts
+     */
+    static async uploadBlob(file, options = {}) {
+        return _a.uploadFile(file, options);
+    }
+    /**
+     * Upload file from filesystem path (Node.js only)
+     */
+    static async _uploadFromPath(filePath, options) {
+        // Dynamic import for Node.js modules
+        const fs = await import('fs');
+        const mime = await import('mime-types');
+        // Validate file exists
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        const stats = fs.statSync(filePath);
+        const fileSize = stats.size;
+        const fileName = filePath.split(/[\\/]/).pop() || "upload";
+        const mimeType = mime.default.lookup(filePath) || "application/octet-stream";
+        const client = new YetterImageClient({
+            apiKey: _a.apiKey,
+            endpoint: _a.endpoint,
+        });
+        // Step 1: Request presigned URL(s)
+        const uploadUrlResponse = await client.getUploadUrl({
+            file_name: fileName,
+            content_type: mimeType,
+            size: fileSize,
+        });
+        // Step 2: Upload file content
+        if (uploadUrlResponse.mode === "single") {
+            await _a._uploadFileSingle(filePath, uploadUrlResponse.put_url, mimeType, fileSize, options, fs);
+        }
+        else {
+            await _a._uploadFileMultipart(filePath, uploadUrlResponse.part_urls, uploadUrlResponse.part_size, fileSize, options, fs);
+        }
+        // Step 3: Notify completion
+        const result = await client.uploadComplete({
+            key: uploadUrlResponse.key,
+        });
+        if (options.onProgress) {
+            options.onProgress(100);
+        }
+        return result;
+    }
+    /**
+     * Upload file from Blob/File object (browser)
+     */
+    static async _uploadFromBlob(file, options) {
+        const fileSize = file.size;
+        const fileName = options.filename ||
+            (file instanceof File ? file.name : "blob-upload");
+        const mimeType = file.type || "application/octet-stream";
+        const client = new YetterImageClient({
+            apiKey: _a.apiKey,
+            endpoint: _a.endpoint,
+        });
+        // Step 1: Request presigned URL(s)
+        const uploadUrlResponse = await client.getUploadUrl({
+            file_name: fileName,
+            content_type: mimeType,
+            size: fileSize,
+        });
+        // Step 2: Upload file content
+        if (uploadUrlResponse.mode === "single") {
+            await _a._uploadBlobSingle(file, uploadUrlResponse.put_url, mimeType, fileSize, options);
+        }
+        else {
+            await _a._uploadBlobMultipart(file, uploadUrlResponse.part_urls, uploadUrlResponse.part_size, fileSize, options);
+        }
+        // Step 3: Notify completion
+        const result = await client.uploadComplete({
+            key: uploadUrlResponse.key,
+        });
+        if (options.onProgress) {
+            options.onProgress(100);
+        }
+        return result;
+    }
+    /**
+     * Upload file using single PUT request (Node.js, private helper)
+     */
+    static async _uploadFileSingle(filePath, presignedUrl, contentType, totalSize, options, fs) {
+        const fileBuffer = fs.readFileSync(filePath);
+        const response = await fetch(presignedUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": contentType,
+                "Content-Length": String(totalSize),
+            },
+            body: fileBuffer,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Single-part upload failed (${response.status}): ${errorText}`);
+        }
+        if (options.onProgress) {
+            options.onProgress(90);
+        }
+    }
+    /**
+     * Upload file using multipart upload (Node.js, private helper)
+     */
+    static async _uploadFileMultipart(filePath, partUrls, partSize, totalSize, options, fs) {
+        const sortedParts = [...partUrls].sort((a, b) => a.part_number - b.part_number);
+        const fileHandle = fs.openSync(filePath, "r");
+        try {
+            for (let i = 0; i < sortedParts.length; i++) {
+                const part = sortedParts[i];
+                const buffer = Buffer.alloc(partSize);
+                const offset = (part.part_number - 1) * partSize;
+                const bytesRead = fs.readSync(fileHandle, buffer, 0, partSize, offset);
+                const chunk = buffer.slice(0, bytesRead);
+                if (chunk.length === 0) {
+                    break;
+                }
+                const response = await fetch(part.url, {
+                    method: "PUT",
+                    headers: {
+                        "Content-Length": String(chunk.length),
+                    },
+                    body: chunk,
+                });
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    throw new Error(`Multipart upload failed at part ${part.part_number} ` +
+                        `(${response.status}): ${errorText}`);
+                }
+                if (options.onProgress) {
+                    const progress = Math.min(90, Math.floor(((i + 1) / sortedParts.length) * 90));
+                    options.onProgress(progress);
+                }
+            }
+        }
+        finally {
+            fs.closeSync(fileHandle);
+        }
+    }
+    /**
+     * Upload blob using single PUT request (browser, private helper)
+     */
+    static async _uploadBlobSingle(blob, presignedUrl, contentType, totalSize, options) {
+        const response = await fetch(presignedUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": contentType,
+                "Content-Length": String(totalSize),
+            },
+            body: blob,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Single-part upload failed (${response.status}): ${errorText}`);
+        }
+        if (options.onProgress) {
+            options.onProgress(90);
+        }
+    }
+    /**
+     * Upload blob using multipart upload (browser, private helper)
+     */
+    static async _uploadBlobMultipart(blob, partUrls, partSize, totalSize, options) {
+        const sortedParts = [...partUrls].sort((a, b) => a.part_number - b.part_number);
+        for (let i = 0; i < sortedParts.length; i++) {
+            const part = sortedParts[i];
+            const start = (part.part_number - 1) * partSize;
+            const end = Math.min(start + partSize, totalSize);
+            const chunk = blob.slice(start, end);
+            if (chunk.size === 0) {
+                break;
+            }
+            const response = await fetch(part.url, {
+                method: "PUT",
+                headers: {
+                    "Content-Length": String(chunk.size),
+                },
+                body: chunk,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Multipart upload failed at part ${part.part_number} ` +
+                    `(${response.status}): ${errorText}`);
+            }
+            if (options.onProgress) {
+                const progress = Math.min(90, Math.floor(((i + 1) / sortedParts.length) * 90));
+                options.onProgress(progress);
+            }
+        }
+    }
 }
 _a = yetter;
 yetter.apiKey = 'Key ' + (process.env.YTR_API_KEY || process.env.REACT_APP_YTR_API_KEY || "");

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export { YetterImageClient } from "./api.js";
 export * from "./types.js";
 export { yetter } from "./client.js";
+export type { UploadOptions, GetUploadUrlRequest, GetUploadUrlResponse, UploadCompleteRequest, UploadCompleteResponse, } from "./types.js";

package/dist/types.d.ts

@@ -90,3 +90,63 @@ export interface YetterStream extends AsyncIterable<StreamEvent> {
     cancel(): Promise<void>;
     getRequestId(): string;
 }
+/**
+ * Options for yetter.uploadFile() and yetter.uploadBlob()
+ */
+export interface UploadOptions {
+    /** Optional callback for upload progress (0-100) */
+    onProgress?: (progress: number) => void;
+    /** Optional custom filename (browser File uploads) */
+    filename?: string;
+}
+/**
+ * Request to get presigned upload URL(s)
+ */
+export interface GetUploadUrlRequest {
+    /** Original filename with extension */
+    file_name: string;
+    /** MIME type (e.g., "image/jpeg") */
+    content_type: string;
+    /** File size in bytes */
+    size: number;
+}
+/**
+ * Response containing presigned URL(s) for upload
+ */
+export interface GetUploadUrlResponse {
+    /** Upload mode: "single" for small files, "multipart" for large files */
+    mode: "single" | "multipart";
+    /** S3 object key for tracking */
+    key: string;
+    /** Presigned PUT URL (single mode only) */
+    put_url?: string;
+    /** Size of each part in bytes (multipart mode only) */
+    part_size?: number;
+    /** Array of part URLs with part numbers (multipart mode only) */
+    part_urls?: Array<{
+        part_number: number;
+        url: string;
+    }>;
+}
+/**
+ * Request to notify upload completion
+ */
+export interface UploadCompleteRequest {
+    /** S3 object key from GetUploadUrlResponse */
+    key: string;
+}
+/**
+ * Response after successful upload completion
+ */
+export interface UploadCompleteResponse {
+    /** Public URL to access the uploaded file */
+    url: string;
+    /** S3 object key */
+    key: string;
+    /** Optional metadata */
+    metadata?: {
+        size: number;
+        content_type: string;
+        uploaded_at?: string;
+    };
+}

package/examples/submit.ts

@@ -44,7 +44,7 @@ async function main() {
                         console.log("Prompt:", finalResult.data.prompt);
                         success = true;
                         break; // Exit loop on success
-                    } else if (currentStatus === "FAILED") {
+                    } else if (currentStatus === "ERROR") {
                         console.error(`Request ${request_id} FAILED. Logs:`, statusResult.data.logs);
                         break; // Exit loop on failure
                     }

package/examples/subscribe.ts

@@ -19,7 +19,7 @@ async function main() {
                     update.logs.map((log) => log.message).forEach(logMessage => console.log(`  - ${logMessage}`));
                 } else if (update.status === "COMPLETED") {
                     console.log("Processing completed!");
-                } else if (update.status === "FAILED") {
+                } else if (update.status === "ERROR") {
                     console.error("Processing failed. Logs:", update.logs);
                 }
             },

package/examples/upload-and-generate.ts

@@ -0,0 +1,39 @@
+import { yetter } from "../src/client.js";
+
+async function main() {
+    // Configure with API key
+    yetter.configure({
+        apiKey: process.env.YTR_API_KEY || "your_api_key_here"
+    });
+
+    console.log("Step 1: Uploading input image...");
+
+    // Replace with your actual image path
+    const imagePath = "./test-image.jpg";
+
+    try {
+        const uploadResult = await yetter.uploadFile(imagePath, {
+            onProgress: (pct) => console.log(`  Upload progress: ${pct}%`),
+        });
+        console.log(`✓ Uploaded: ${uploadResult.url}\n`);
+
+        console.log("Step 2: Generating with uploaded image...");
+        const genResult = await yetter.subscribe("ytr-ai/qwen/image-edit/i2i", {
+            input: {
+                prompt: "Transform to watercolor painting style",
+                image_url: [uploadResult.url],
+                num_inference_steps: 28,
+            },
+            onQueueUpdate: (status) => {
+                console.log(`  Status: ${status.status}, Queue: ${status.queue_position}`);
+            },
+        });
+
+        console.log("\n✓ Generation complete!");
+        console.log("Generated images:", genResult.images);
+    } catch (error: any) {
+        console.error("Error:", error.message);
+    }
+}
+
+main().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yetter/client",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "type": "module",
   "scripts": {
     "build": "tsc",
@@ -23,9 +23,11 @@
   "description": "",
   "dependencies": {
     "@types/eventsource": "^1.1.15",
+    "@types/mime-types": "^3.0.1",
     "cross-fetch": "^4.1.0",
     "event-source-polyfill": "^1.0.31",
-    "eventsource": "^4.0.0"
+    "eventsource": "^4.0.0",
+    "mime-types": "^3.0.2"
   },
   "devDependencies": {
     "@types/event-source-polyfill": "^1.0.5",

package/src/api.ts

@@ -9,6 +9,10 @@ import {
     CancelResponse,
     GetResponseRequest,
     GetResponseResponse,
+    GetUploadUrlRequest,
+    GetUploadUrlResponse,
+    UploadCompleteRequest,
+    UploadCompleteResponse,
 } from "./types";
 
 export class YetterImageClient {
@@ -102,4 +106,54 @@ export class YetterImageClient {
         }
         return (await res.json()) as GetResponseResponse;
     }
+
+    /**
+     * Request presigned URL(s) for file upload
+     * @param body Upload request parameters
+     * @returns Presigned URL response with mode (single/multipart)
+     */
+    public async getUploadUrl(
+        body: GetUploadUrlRequest
+    ): Promise<GetUploadUrlResponse> {
+        const res = await fetch(`${this.endpoint}/uploads`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: this.apiKey,
+            },
+            body: JSON.stringify(body),
+        });
+
+        if (!res.ok) {
+            const errorText = await res.text();
+            throw new Error(`Upload URL request failed (${res.status}): ${errorText}`);
+        }
+
+        return (await res.json()) as GetUploadUrlResponse;
+    }
+
+    /**
+     * Notify server that upload is complete
+     * @param body Completion request with S3 key
+     * @returns Uploaded file metadata with public URL
+     */
+    public async uploadComplete(
+        body: UploadCompleteRequest
+    ): Promise<UploadCompleteResponse> {
+        const res = await fetch(`${this.endpoint}/uploads/complete`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: this.apiKey,
+            },
+            body: JSON.stringify(body),
+        });
+
+        if (!res.ok) {
+            const errorText = await res.text();
+            throw new Error(`Upload completion failed (${res.status}): ${errorText}`);
+        }
+
+        return (await res.json()) as UploadCompleteResponse;
+    }
 }