@yetter/client 0.0.3 → 0.0.4

package/README.md

@@ -10,12 +10,26 @@ npm install @yetter/client
 
 ## Authentication
 
-The client requires a Yetter API key for authentication. Ensure you have the `YTR_API_KEY` environment variable set:
+The client requires a Yetter API key for authentication. Ensure you have the `YTR_API_KEY` or `REACT_APP_YTR_API_KEY` environment variable set:
 
 ```bash
 export YTR_API_KEY="your_api_key_here"
+export REACT_APP_YTR_API_KEY="your_api_key_here"
 ```
 
+Alternatively, you can configure the API key (and optionally the API endpoint) programmatically using the `yetter.configure()` method. This is useful if you prefer not to use environment variables or need to set the key at runtime.
+
+```typescript
+import { yetter } from "@yetter/client";
+
+yetter.configure({
+  apiKey: "your_api_key_here",
+  // endpoint: "https://custom.api.yetter.ai" // if you need to override the default endpoint
+});
+```
+
+If `yetter.configure()` is used, it will override any API key found in environment variables for subsequent API calls. If neither environment variables are set nor `yetter.configure()` is called with an API key, an error will be thrown when attempting to make an API call.
+
 ## 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).

package/dist/client.d.ts

@@ -1,5 +1,8 @@
-import { GetResponseResponse, SubscribeOptions, GenerateImageResponse, SubmitQueueOptions, GetResultOptions, GetResultResponse, StatusOptions, StatusResponse, StreamOptions, YetterStream } from "./types.js";
+import { ClientOptions, GetResponseResponse, SubscribeOptions, GenerateImageResponse, SubmitQueueOptions, GetResultOptions, GetResultResponse, StatusOptions, StatusResponse, StreamOptions, YetterStream } from "./types.js";
 export declare class yetter {
+    private static apiKey;
+    private static endpoint;
+    static configure(options: ClientOptions): void;
     static subscribe(model: string, options: SubscribeOptions): Promise<GetResponseResponse>;
     static queue: {
         submit: (model: string, options: SubmitQueueOptions) => Promise<GenerateImageResponse>;

package/dist/client.js

@@ -2,13 +2,22 @@ var _a;
 import { YetterImageClient } from "./api.js";
 import { EventSourcePolyfill } from 'event-source-polyfill';
 export class yetter {
+    static configure(options) {
+        if (options.apiKey) {
+            _a.apiKey = options.apiKey;
+        }
+        if (options.endpoint) {
+            _a.endpoint = options.endpoint;
+        }
+    }
     static async subscribe(model, options) {
         var _b;
-        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");
+        if (!_a.apiKey) {
+            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
         }
         const client = new YetterImageClient({
-            apiKey: process.env.YTR_API_KEY || process.env.REACT_APP_YTR_API_KEY || "",
+            apiKey: _a.apiKey,
+            endpoint: _a.endpoint,
         });
         const generateResponse = await client.generateImage({
             model: model,
@@ -55,11 +64,12 @@ export class yetter {
         return finalResponse;
     }
     static async stream(model, options) {
-        if (!process.env.YTR_API_KEY) {
-            throw new Error("YTR_API_KEY is not set");
+        if (!_a.apiKey) {
+            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
         }
         const apiClient = new YetterImageClient({
-            apiKey: process.env.YTR_API_KEY,
+            apiKey: _a.apiKey,
+            endpoint: _a.endpoint,
         });
         const initialApiResponse = await apiClient.generateImage({
             model: model,
@@ -154,7 +164,7 @@ export class yetter {
             }
         };
         eventSource = new EventSourcePolyfill(sseStreamUrl, {
-            headers: { 'Authorization': `${process.env.YTR_API_KEY}` }
+            headers: { 'Authorization': `${_a.apiKey}` }
         });
         eventSource.onopen = (event) => {
             console.log("SSE Connection Opened:", event);
@@ -214,13 +224,16 @@ export class yetter {
     }
 }
 _a = yetter;
+yetter.apiKey = process.env.YTR_API_KEY || process.env.REACT_APP_YTR_API_KEY || "";
+yetter.endpoint = "https://api.yetter.ai";
 yetter.queue = {
     submit: async (model, options) => {
-        if (!process.env.YTR_API_KEY) {
-            throw new Error("YTR_API_KEY is not set");
+        if (!_a.apiKey) {
+            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
         }
         const client = new YetterImageClient({
-            apiKey: process.env.YTR_API_KEY,
+            apiKey: _a.apiKey,
+            endpoint: _a.endpoint,
         });
         const generateResponse = await client.generateImage({
             model: model,
@@ -229,11 +242,12 @@ yetter.queue = {
         return generateResponse;
     },
     status: async (model, options) => {
-        if (!process.env.YTR_API_KEY) {
-            throw new Error("YTR_API_KEY is not set");
+        if (!_a.apiKey) {
+            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
         }
         const client = new YetterImageClient({
-            apiKey: process.env.YTR_API_KEY,
+            apiKey: _a.apiKey,
+            endpoint: _a.endpoint,
         });
         const endpoint = client.getApiEndpoint();
         const statusUrl = `${endpoint}/${model}/requests/${options.requestId}/status`;
@@ -244,11 +258,12 @@ yetter.queue = {
         };
     },
     result: async (model, options) => {
-        if (!process.env.YTR_API_KEY) {
-            throw new Error("YTR_API_KEY is not set");
+        if (!_a.apiKey) {
+            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
         }
         const client = new YetterImageClient({
-            apiKey: process.env.YTR_API_KEY,
+            apiKey: _a.apiKey,
+            endpoint: _a.endpoint,
         });
         const endpoint = client.getApiEndpoint();
         const responseUrl = `${endpoint}/${model}/requests/${options.requestId}`;

package/package.json

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

package/src/client.ts

@@ -1,6 +1,7 @@
 import { YetterImageClient } from "./api.js";
 import { EventSourcePolyfill } from 'event-source-polyfill';
 import {
+    ClientOptions,
     GetStatusResponse,
     GetResponseResponse,
     SubscribeOptions,
@@ -16,15 +17,28 @@ import {
 } from "./types.js";
 
 export class yetter {
+    private static apiKey: string = process.env.YTR_API_KEY || process.env.REACT_APP_YTR_API_KEY || "";
+    private static endpoint: string = "https://api.yetter.ai";
+
+    public static configure(options: ClientOptions) {
+        if (options.apiKey) {
+            yetter.apiKey = options.apiKey;
+        }
+        if (options.endpoint) {
+            yetter.endpoint = options.endpoint;
+        }
+    }
+
     public static async subscribe(
         model: string,
         options: SubscribeOptions
     ): Promise<GetResponseResponse> {
-        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");
+        if (!yetter.apiKey) {
+            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
         }
         const client = new YetterImageClient({
-            apiKey: process.env.YTR_API_KEY || process.env.REACT_APP_YTR_API_KEY || "",
+            apiKey: yetter.apiKey,
+            endpoint: yetter.endpoint,
         });
 
         const generateResponse = await client.generateImage({
@@ -83,11 +97,12 @@ export class yetter {
             model: string,
             options: SubmitQueueOptions
         ): Promise<GenerateImageResponse> => {
-            if (!process.env.YTR_API_KEY) {
-                throw new Error("YTR_API_KEY is not set");
+            if (!yetter.apiKey) {
+                throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
             }
             const client = new YetterImageClient({
-                apiKey: process.env.YTR_API_KEY,
+                apiKey: yetter.apiKey,
+                endpoint: yetter.endpoint,
             });
 
             const generateResponse = await client.generateImage({
@@ -102,11 +117,12 @@ export class yetter {
             model: string,
             options: StatusOptions
         ): Promise<StatusResponse> => {
-            if (!process.env.YTR_API_KEY) {
-                throw new Error("YTR_API_KEY is not set");
+            if (!yetter.apiKey) {
+                throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
             }
             const client = new YetterImageClient({
-                apiKey: process.env.YTR_API_KEY,
+                apiKey: yetter.apiKey,
+                endpoint: yetter.endpoint,
             });
 
             const endpoint = client.getApiEndpoint();
@@ -125,11 +141,12 @@ export class yetter {
             model: string,
             options: GetResultOptions
         ): Promise<GetResultResponse> => {
-            if (!process.env.YTR_API_KEY) {
-                throw new Error("YTR_API_KEY is not set");
+            if (!yetter.apiKey) {
+                throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
             }
             const client = new YetterImageClient({
-                apiKey: process.env.YTR_API_KEY,
+                apiKey: yetter.apiKey,
+                endpoint: yetter.endpoint,
             });
 
             const endpoint = client.getApiEndpoint();
@@ -149,11 +166,12 @@ export class yetter {
         model: string,
         options: StreamOptions
     ): Promise<YetterStream> {
-        if (!process.env.YTR_API_KEY) {
-            throw new Error("YTR_API_KEY is not set");
+        if (!yetter.apiKey) {
+            throw new Error("API key is not configured. Call yetter.configure({ apiKey: 'your_key' }) or set YTR_API_KEY.");
         }
         const apiClient = new YetterImageClient({
-            apiKey: process.env.YTR_API_KEY,
+            apiKey: yetter.apiKey,
+            endpoint: yetter.endpoint,
         });
 
         const initialApiResponse = await apiClient.generateImage({
@@ -249,7 +267,7 @@ export class yetter {
         };
 
         eventSource = new EventSourcePolyfill(sseStreamUrl, {
-            headers: { 'Authorization': `${process.env.YTR_API_KEY}` }
+            headers: { 'Authorization': `${yetter.apiKey}` }
         } as any);
 
         eventSource.onopen = (event: Event) => {

package/stress.ts

@@ -1,135 +0,0 @@
-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);
-});