@yetter/client 0.0.2 → 0.0.3

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.2",
+  "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);
+});