@yetter/client 0.0.1 → 0.0.3

package/README.md

@@ -0,0 +1,220 @@
+# Yetter JS Client
+
+The Yetter JS Client provides a convenient way to interact with the Yetter API for image generation. It supports different modes of operation: subscribing to real-time updates, submitting jobs to a queue, and streaming events.
+
+## Installation
+
+```bash
+npm install @yetter/client
+```
+
+## Authentication
+
+The client requires a Yetter API key for authentication. Ensure you have the `YTR_API_KEY` environment variable set:
+
+```bash
+export YTR_API_KEY="your_api_key_here"
+```
+
+## Core Functionalities
+
+The client is available via the `yetter` object imported from `yetter-js` (or the relevant path to `client.js`/`client.ts` if used directly).
+
+```typescript
+import { yetter } from "@yetter/client";
+```
+
+### 1. `yetter.subscribe()`
+
+This function submits an image generation request and long-polls for the result. It provides updates on the queue status and logs if requested.
+
+**Features:**
+- Submits a generation request.
+- Polls for status updates until the job is "COMPLETED" or "FAILED".
+- Timeout after 30 minutes, with an attempt to cancel the job.
+- Optional `onQueueUpdate` callback for real-time feedback on queue position and status.
+- Optional `logs` flag to include logs in status updates.
+
+**Example (from `examples/subscribe.ts`):**
+
+```typescript
+import { yetter } from "@yetter/client";
+
+async function main() {
+    const model = "ytr-ai/flux/dev"; // Replace with your desired model
+    try {
+        console.log("\n--- Starting Subscribe Test ---");
+        const result = await yetter.subscribe(model, {
+            input: {
+                prompt: "a vibrant coral reef, underwater photography",
+            },
+            logs: true,
+            onQueueUpdate: (update) => {
+                console.log(`[Queue Update] Status: ${update.status}, Position: ${update.queue_position}`);
+                if (update.status === "IN_PROGRESS" && update.logs) {
+                    console.log("Logs:");
+                    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") {
+                    console.error("Processing failed. Logs:", update.logs);
+                }
+            },
+        });
+
+        console.log("\n--- Subscribe Test Result ---");
+        console.log("Results:", result); // Contains image data, prompt, etc.
+
+    } catch (err: any) {
+        console.error("\n--- Subscribe Test Failed ---");
+        console.error("Error during subscribe:", err.message || err);
+        // ... error handling ...
+    }
+}
+
+main();
+```
+
+### 2. `yetter.stream()`
+
+This function submits an image generation request and returns an async iterable stream of events using Server-Sent Events (SSE). This allows for real-time updates on the job's progress, status, and logs.
+
+**Features:**
+-   Initiates a request and establishes an SSE connection.
+-   Provides an `AsyncIterator` (`Symbol.asyncIterator`) to loop through status events (`StreamEvent`).
+-   A `done()` method: Returns a Promise that resolves with the final `GetResponseResponse` when the job is "COMPLETED", or rejects if it "FAILED" or the stream is prematurely closed.
+-   A `cancel()` method: Closes the stream and attempts to cancel the underlying image generation request.
+-   A `getRequestId()` method: Returns the request ID for the stream.
+
+**Events (`StreamEvent`):**
+Each event pushed by the stream is an object typically including:
+-   `status`: Current status (e.g., "IN_QUEUE", "IN_PROGRESS", "COMPLETED", "FAILED").
+-   `queue_position`: Current position in the queue.
+-   `logs`: Array of log messages if any.
+-   Other model-specific data.
+
+**Example (from `examples/stream.ts`):**
+
+```typescript
+import { yetter } from "@yetter/client"; // Adjust path as needed
+
+async function main() {
+    const model = "ytr-ai/flux/dev";
+    let streamRequestId = "";
+    try {
+        console.log("\n--- Starting Stream Test ---");
+        const streamInstance = await yetter.stream(model, {
+            input: {
+                prompt: "a bioluminescent forest at night, fantasy art",
+            },
+        });
+        streamRequestId = streamInstance.getRequestId();
+        console.log(`Stream initiated for Request ID: ${streamRequestId}`);
+
+        // Iterate over stream events
+        for await (const event of streamInstance) {
+            console.log(`[STREAM EVENT - ${streamRequestId}] Status: ${event.status}, QPos: ${event.queue_position}`);
+            if (event.logs && event.logs.length > 0) {
+                console.log(`  Logs for ${streamRequestId}:`);
+                event.logs.forEach(log => console.log(`    - ${log.message}`));
+            }
+        }
+        console.log(`Stream for ${streamRequestId} finished iterating events.`);
+
+        // Wait for the final result from the done() method
+        const result = await streamInstance.done();
+        console.log("\n--- Stream Test Final Result ---");
+        console.log("Generated Images:", result.images);
+
+    } catch (err: any) {
+        console.error(`\n--- Stream Test Failed (Request ID: ${streamRequestId || 'UNKNOWN'}) ---`);
+        console.error("Error during stream test:", err.message || err);
+    }
+}
+
+main();
+```
+
+### 3. `yetter.queue`
+
+This namespace provides methods for managing jobs in a queue-based workflow. This is useful if you want to submit a job and check its status or retrieve its result later, without maintaining a persistent connection.
+
+#### `yetter.queue.submit(model, options)`
+Submits a job to the queue.
+
+-   **`model`**: The model ID (e.g., `"ytr-ai/flux/dev"`).
+-   **`options.input`**: An object containing the input parameters for the model (e.g., `{ prompt: "your prompt" }`).
+
+Returns a promise that resolves to an object containing `request_id`, `status`, and `queue_position`.
+
+#### `yetter.queue.status(model, options)`
+Checks the status of a previously submitted job.
+
+-   **`model`**: The model ID.
+-   **`options.requestId`**: The `request_id` obtained from `queue.submit()`.
+
+Returns a promise that resolves to an object containing the status data and `requestId`.
+
+#### `yetter.queue.result(model, options)`
+Retrieves the result of a completed job.
+
+-   **`model`**: The model ID.
+-   **`options.requestId`**: The `request_id` of the completed job.
+
+Returns a promise that resolves to an object containing the result data (e.g., images, prompt) and `requestId`.
+
+**Example (from `examples/submit.ts`):**
+
+```typescript
+import { yetter } from "@yetter/client";
+
+async function main() {
+    const model = "ytr-ai/flux/dev";
+    try {
+        console.log("\n--- Starting Queue Submit Test ---");
+        const { request_id } = await yetter.queue.submit(model, {
+            input: {
+                prompt: "a fluffy white kitten playing with a yarn ball",
+            },
+        });
+        console.log("Request ID:", request_id);
+
+        if (request_id) {
+            console.log(`\n--- Polling for status of Request ID: ${request_id} ---`);
+            // Polling logic:
+            let success = false;
+            const startTime = Date.now();
+            const timeoutMilliseconds = 3 * 60 * 1000; // 3 minutes
+            const pollIntervalMilliseconds = 10 * 1000; // Poll every 10 seconds
+
+            while (Date.now() - startTime < timeoutMilliseconds) {
+                const statusResult = await yetter.queue.status(model, { requestId: request_id });
+                const currentStatus = statusResult.data.status;
+                console.log(`[${new Date().toLocaleTimeString()}] Status: ${currentStatus}, QPos: ${statusResult.data.queue_position}`);
+
+                if (currentStatus === "COMPLETED") {
+                    const finalResult = await yetter.queue.result(model, { requestId: request_id });
+                    console.log("\n--- Get Result Test Succeeded ---");
+                    console.log("Image Data:", finalResult.data.images);
+                    success = true;
+                    break;
+                } else if (currentStatus === "FAILED") {
+                    console.error(`Request ${request_id} FAILED. Logs:`, statusResult.data.logs);
+                    break;
+                }
+                await new Promise(resolve => setTimeout(resolve, pollIntervalMilliseconds));
+            }
+            if (!success) console.error(`Polling Timed Out or Failed for ${request_id}`);
+        }
+    } catch (err: any) {
+        console.error("\n--- Queue Submit Test Failed ---", err.message);
+    }
+}
+
+main();
+```
+
+## Error Handling
+
+The client functions generally throw errors for API issues, network problems, or failed generation requests. Ensure you wrap API calls in `try...catch` blocks to handle potential errors gracefully. Specific error messages or details (like logs for failed jobs) are often included in the thrown error object or the final status response.
+The `stream()` function's `done()` promise will reject on failure or premature closure, and iterating the stream might also throw if connection errors occur.

package/dist/client.js

@@ -4,11 +4,11 @@ import { EventSourcePolyfill } from 'event-source-polyfill';
 export class yetter {
     static async subscribe(model, options) {
         var _b;
-        if (!process.env.YTR_API_KEY) {
-            throw new Error("YTR_API_KEY is not set");
+        if (!process.env.YTR_API_KEY && !process.env.REACT_APP_YTR_API_KEY) {
+            throw new Error("YTR_API_KEY and REACT_APP_YTR_API_KEY are not set");
         }
         const client = new YetterImageClient({
-            apiKey: process.env.YTR_API_KEY,
+            apiKey: process.env.YTR_API_KEY || process.env.REACT_APP_YTR_API_KEY || "",
         });
         const generateResponse = await client.generateImage({
             model: model,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yetter/client",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "scripts": {
     "build": "tsc",

package/src/client.ts

@@ -20,11 +20,11 @@ export class yetter {
         model: string,
         options: SubscribeOptions
     ): Promise<GetResponseResponse> {
-        if (!process.env.YTR_API_KEY) {
-            throw new Error("YTR_API_KEY is not set");
+        if (!process.env.YTR_API_KEY && !process.env.REACT_APP_YTR_API_KEY) {
+            throw new Error("YTR_API_KEY and REACT_APP_YTR_API_KEY are not set");
         }
         const client = new YetterImageClient({
-            apiKey: process.env.YTR_API_KEY,
+            apiKey: process.env.YTR_API_KEY || process.env.REACT_APP_YTR_API_KEY || "",
         });
 
         const generateResponse = await client.generateImage({

package/stress.ts

@@ -0,0 +1,135 @@
+import { yetter } from "../src/client.js";
+
+const CONCURRENCY_LEVEL = 5; // Number of streams to run in parallel
+const MODEL_NAME = "ytr-ai/flux/dev"; // Model to use for streaming
+
+let streamCounter = 0;
+const activePromises: Promise<void>[] = [];
+let shuttingDown = false;
+
+/**
+ * Runs a single stream, measures latency, and logs results.
+ * @param id - A unique identifier for the stream.
+ */
+async function runStream(id: number): Promise<void> {
+    const startTime = Date.now();
+    let streamRequestId = "";
+
+    console.log(`[${new Date().toLocaleTimeString()}] [Stream ${id}] Starting...`);
+
+    try {
+        const streamInstance = await yetter.stream(MODEL_NAME, {
+            input: {
+                prompt: `A beautiful landscape painting, style of Van Gogh, stream ${id}`,
+                // You can add other parameters like seed or num_inference_steps here
+            },
+        });
+        streamRequestId = streamInstance.getRequestId();
+        console.log(`[${new Date().toLocaleTimeString()}] [Stream ${id}] Initiated. Request ID: ${streamRequestId}`);
+
+        // We are primarily interested in the latency of done(), so event iteration can be minimal or skipped.
+        // for await (const event of streamInstance) {
+        //     console.log(`[${new Date().toLocaleTimeString()}][STREAM EVENT - ${streamRequestId}] Status: ${event.status}, QPos: ${event.queue_position}`);
+        // }
+
+        // Wait for the final result from the done() method
+        await streamInstance.done();
+        const endTime = Date.now();
+        const latency = endTime - startTime;
+        console.log(`[${new Date().toLocaleTimeString()}] [Stream ${id}] Finished. Request ID: ${streamRequestId}. Latency: ${latency}ms`);
+
+    } catch (err: any) {
+        const endTime = Date.now();
+        const latency = endTime - startTime; // Still record latency up to the point of failure
+        console.error(`[${new Date().toLocaleTimeString()}] [Stream ${id}] Failed. Request ID: ${streamRequestId || 'UNKNOWN'}. Latency: ${latency}ms. Error: ${err.message || err}`);
+        // Optionally, rethrow or handle more specifically if needed
+    }
+}
+
+/**
+ * Launches a new stream if concurrency limit is not reached and not shutting down.
+ * Manages the activePromises array.
+ */
+async function launchStreamIfNotBusy(): Promise<void> {
+    if (shuttingDown || activePromises.length >= CONCURRENCY_LEVEL) {
+        return;
+    }
+
+    streamCounter++;
+    const currentStreamId = streamCounter;
+    
+    console.log(`[${new Date().toLocaleTimeString()}] Launching stream ${currentStreamId}. Active: ${activePromises.length}/${CONCURRENCY_LEVEL}`);
+    
+    const streamTask = runStream(currentStreamId);
+    activePromises.push(streamTask);
+
+    try {
+        await streamTask;
+    } catch (e) {
+        // Errors are logged within runStream
+    } finally {
+        const index = activePromises.indexOf(streamTask);
+        if (index > -1) {
+            activePromises.splice(index, 1);
+        }
+        console.log(`[${new Date().toLocaleTimeString()}] Stream ${currentStreamId} completed. Active: ${activePromises.length}/${CONCURRENCY_LEVEL}`);
+        // After a stream finishes, try to fill its slot immediately
+        if (!shuttingDown) {
+            launchStreamIfNotBusy(); // Non-blocking call to fill the slot
+        }
+    }
+}
+
+/**
+ * Fills available slots up to the CONCURRENCY_LEVEL.
+ */
+function fillSlots() {
+    while (!shuttingDown && activePromises.length < CONCURRENCY_LEVEL) {
+        // launchStreamIfNotBusy is async but we don't await it here
+        // as we want to launch multiple streams in parallel.
+        // It handles its own addition to activePromises.
+        launchStreamIfNotBusy();
+    }
+}
+
+/**
+ * Main function to run the stress test.
+ */
+async function mainStressTest() {
+    console.log("--- Starting Yetter Stream Stress Test ---");
+    console.log(`Concurrency Level (N): ${CONCURRENCY_LEVEL}`);
+    console.log(`Target Model: ${MODEL_NAME}`);
+    console.log("Press Ctrl+C to stop gracefully (will finish active streams).");
+
+    process.on('SIGINT', async () => {
+        console.log('\nSIGINT received. Gracefully shutting down...');
+        shuttingDown = true;
+        console.log(`No new streams will be launched. Waiting for ${activePromises.length} active stream(s) to complete...`);
+        // The main loop will exit once activePromises is empty after shuttingDown is true.
+    });
+
+    // Initial fill
+    fillSlots();
+
+    // Keep the script running and responsive to shutdown, also periodically check to fill slots
+    // in case some mechanism external to stream completion is needed (though launchStreamIfNotBusy's finally block should cover it)
+    while (true) {
+        if (shuttingDown && activePromises.length === 0) {
+            break; // Exit condition: shutting down and all streams are done.
+        }
+        // Periodically try to fill slots, mainly as a fallback or if initial fills didn't max out.
+        // The primary mechanism for refilling is within launchStreamIfNotBusy's finally block.
+        if (!shuttingDown) {
+            fillSlots();
+        }
+        await new Promise(resolve => setTimeout(resolve, 200)); // Interval for the main loop check
+    }
+
+    console.log('--- Stress Test Finished ---');
+    console.log(`Total streams launched during the session: ${streamCounter}`);
+}
+
+mainStressTest().catch(err => {
+    console.error("Unhandled error in mainStressTest:", err);
+    process.exit(1);
+});