@yetter/client 0.0.1

package/dist/api.d.ts

@@ -0,0 +1,11 @@
+import { ClientOptions, GenerateImageRequest, GenerateImageResponse, GetStatusRequest, GetStatusResponse, CancelRequest, CancelResponse, GetResponseRequest, GetResponseResponse } from "./types";
+export declare class YetterImageClient {
+    private apiKey;
+    private endpoint;
+    constructor(options: ClientOptions);
+    getApiEndpoint(): string;
+    generateImage(body: GenerateImageRequest): Promise<GenerateImageResponse>;
+    getStatus(body: GetStatusRequest): Promise<GetStatusResponse>;
+    cancel(body: CancelRequest): Promise<CancelResponse>;
+    getResponse(body: GetResponseRequest): Promise<GetResponseResponse>;
+}

package/dist/api.js

@@ -0,0 +1,75 @@
+import fetch from "cross-fetch";
+export class YetterImageClient {
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error("`apiKey` is required");
+        }
+        this.apiKey = options.apiKey;
+        this.endpoint = options.endpoint || "https://api.yetter.ai";
+    }
+    getApiEndpoint() {
+        return this.endpoint;
+    }
+    async generateImage(body) {
+        const url = `${this.endpoint}/${body.model}`;
+        const res = await fetch(url, {
+            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(`API error (${res.status}): ${errorText}`);
+        }
+        return (await res.json());
+    }
+    async getStatus(body) {
+        const url = new URL(body.url);
+        if (body.logs) {
+            url.searchParams.append('logs', '1');
+        }
+        const res = await fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `${this.apiKey}`,
+            },
+        });
+        if (!res.ok) {
+            const errorText = await res.text();
+            throw new Error(`API error (${res.status}): ${errorText}`);
+        }
+        return (await res.json());
+    }
+    async cancel(body) {
+        const res = await fetch(body.url, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `${this.apiKey}`,
+            },
+        });
+        if (!res.ok) {
+            const errorText = await res.text();
+            throw new Error(`API error (${res.status}): ${errorText}`);
+        }
+        return (await res.json());
+    }
+    async getResponse(body) {
+        const res = await fetch(body.url, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `${this.apiKey}`,
+            },
+        });
+        if (!res.ok) {
+            const errorText = await res.text();
+            throw new Error(`API error (${res.status}): ${errorText}`);
+        }
+        return (await res.json());
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,10 @@
+import { GetResponseResponse, SubscribeOptions, GenerateImageResponse, SubmitQueueOptions, GetResultOptions, GetResultResponse, StatusOptions, StatusResponse, StreamOptions, YetterStream } from "./types.js";
+export declare class yetter {
+    static subscribe(model: string, options: SubscribeOptions): Promise<GetResponseResponse>;
+    static queue: {
+        submit: (model: string, options: SubmitQueueOptions) => Promise<GenerateImageResponse>;
+        status: (model: string, options: StatusOptions) => Promise<StatusResponse>;
+        result: (model: string, options: GetResultOptions) => Promise<GetResultResponse>;
+    };
+    static stream(model: string, options: StreamOptions): Promise<YetterStream>;
+}

package/dist/client.js

@@ -0,0 +1,261 @@
+var _a;
+import { YetterImageClient } from "./api.js";
+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");
+        }
+        const client = new YetterImageClient({
+            apiKey: process.env.YTR_API_KEY,
+        });
+        const generateResponse = await client.generateImage({
+            model: model,
+            ...options.input,
+        });
+        let status = generateResponse.status;
+        let lastStatusResponse;
+        const startTime = Date.now();
+        const timeoutMilliseconds = 30 * 60 * 1000; // 30 minutes
+        while (status !== "COMPLETED" && status !== "FAILED") {
+            if (Date.now() - startTime > timeoutMilliseconds) {
+                console.warn(`Subscription timed out after 30 minutes for request ID: ${generateResponse.request_id}. Attempting to cancel.`);
+                try {
+                    await client.cancel({ url: generateResponse.cancel_url });
+                    console.log(`Cancellation request sent for request ID: ${generateResponse.request_id}.`);
+                }
+                catch (cancelError) {
+                    console.error(`Failed to cancel request ID: ${generateResponse.request_id} after timeout:`, cancelError.message || cancelError);
+                }
+                throw new Error(`Subscription timed out after 30 minutes for request ID: ${generateResponse.request_id}.`);
+            }
+            try {
+                lastStatusResponse = await client.getStatus({
+                    url: generateResponse.status_url,
+                    logs: options.logs,
+                });
+                status = lastStatusResponse.status;
+                if (options.onQueueUpdate) {
+                    options.onQueueUpdate(lastStatusResponse);
+                }
+            }
+            catch (error) {
+                console.error("Error during status polling:", error);
+                throw error;
+            }
+        }
+        if (status === "FAILED") {
+            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);
+        }
+        const finalResponse = await client.getResponse({
+            url: generateResponse.response_url,
+        });
+        return finalResponse;
+    }
+    static async stream(model, options) {
+        if (!process.env.YTR_API_KEY) {
+            throw new Error("YTR_API_KEY is not set");
+        }
+        const apiClient = new YetterImageClient({
+            apiKey: process.env.YTR_API_KEY,
+        });
+        const initialApiResponse = await apiClient.generateImage({
+            model: model,
+            ...options.input,
+        });
+        const requestId = initialApiResponse.request_id;
+        const responseUrl = initialApiResponse.response_url;
+        const cancelUrl = initialApiResponse.cancel_url;
+        const sseStreamUrl = `${apiClient.getApiEndpoint()}/${model}/requests/${requestId}/status/stream`;
+        let eventSource;
+        let streamEnded = false;
+        // Setup the promise for the done() method
+        let resolveDonePromise;
+        let rejectDonePromise;
+        const donePromise = new Promise((resolve, reject) => {
+            resolveDonePromise = resolve;
+            rejectDonePromise = reject;
+        });
+        const controller = {
+            // This will be used by the async iterator to pull events
+            // It needs a way to buffer events or signal availability
+            events: [],
+            resolvers: [],
+            isClosed: false,
+            push(event) {
+                var _b;
+                if (this.isClosed)
+                    return;
+                if (this.resolvers.length > 0) {
+                    this.resolvers.shift()({ value: event, done: false });
+                }
+                else {
+                    this.events.push(event);
+                }
+                // Check for terminal events to resolve/reject the donePromise
+                if (event.status === "COMPLETED") {
+                    streamEnded = true;
+                    apiClient.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();
+                }
+            },
+            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
+                }
+                else {
+                    console.warn("SSE 'onerror' event after stream was considered ended (COMPLETED/FAILED). This error will not alter the done() promise.", err);
+                }
+                streamEnded = true; // Ensure it's marked as ended
+                if (this.resolvers.length > 0) {
+                    this.resolvers.shift()({ value: undefined, done: true }); // Signal error to iterator consumer
+                }
+                this.close(); // Proceed to close EventSource etc.
+            },
+            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) {
+                    return Promise.resolve({ value: this.events.shift(), done: false });
+                }
+                if (this.isClosed) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise(resolve => this.resolvers.push(resolve));
+            }
+        };
+        eventSource = new EventSourcePolyfill(sseStreamUrl, {
+            headers: { 'Authorization': `${process.env.YTR_API_KEY}` }
+        });
+        eventSource.onopen = (event) => {
+            console.log("SSE Connection Opened:", event);
+        };
+        eventSource.addEventListener('data', (event) => {
+            console.log("SSE 'data' event received, raw data:", event.data);
+            try {
+                const statusData = JSON.parse(event.data);
+                controller.push(statusData);
+            }
+            catch (e) {
+                console.error("Error parsing SSE 'data' event:", e, "Raw data:", event.data);
+                controller.error(new Error(`Error parsing SSE 'data' event: ${e.message}`));
+            }
+        });
+        eventSource.addEventListener('done', (event) => {
+            console.log("SSE 'done' event received, raw data:", event.data);
+            controller.close();
+        });
+        eventSource.onerror = (err) => {
+            console.error("SSE Connection Error (onerror):", err);
+            controller.error(err);
+        };
+        // Handle if API immediately returns a terminal status in initialApiResponse (e.g. already completed/failed)
+        if (initialApiResponse.status === "COMPLETED") {
+            controller.push(initialApiResponse);
+        }
+        else if (initialApiResponse.status === "FAILED") {
+            controller.push(initialApiResponse);
+        }
+        return {
+            async *[Symbol.asyncIterator]() {
+                while (!controller.isClosed || controller.events.length > 0) {
+                    const event = await controller.next();
+                    if (event.done)
+                        break;
+                    yield event.value;
+                }
+            },
+            done: () => donePromise,
+            cancel: async () => {
+                controller.close();
+                try {
+                    await apiClient.cancel({ url: cancelUrl });
+                    console.log(`Stream for ${requestId} - underlying request cancelled.`);
+                }
+                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,
+        };
+    }
+}
+_a = yetter;
+yetter.queue = {
+    submit: async (model, options) => {
+        if (!process.env.YTR_API_KEY) {
+            throw new Error("YTR_API_KEY is not set");
+        }
+        const client = new YetterImageClient({
+            apiKey: process.env.YTR_API_KEY,
+        });
+        const generateResponse = await client.generateImage({
+            model: model,
+            ...options.input,
+        });
+        return generateResponse;
+    },
+    status: async (model, options) => {
+        if (!process.env.YTR_API_KEY) {
+            throw new Error("YTR_API_KEY is not set");
+        }
+        const client = new YetterImageClient({
+            apiKey: process.env.YTR_API_KEY,
+        });
+        const endpoint = client.getApiEndpoint();
+        const statusUrl = `${endpoint}/${model}/requests/${options.requestId}/status`;
+        const statusData = await client.getStatus({ url: statusUrl });
+        return {
+            data: statusData,
+            requestId: options.requestId,
+        };
+    },
+    result: async (model, options) => {
+        if (!process.env.YTR_API_KEY) {
+            throw new Error("YTR_API_KEY is not set");
+        }
+        const client = new YetterImageClient({
+            apiKey: process.env.YTR_API_KEY,
+        });
+        const endpoint = client.getApiEndpoint();
+        const responseUrl = `${endpoint}/${model}/requests/${options.requestId}`;
+        const responseData = await client.getResponse({ url: responseUrl });
+        return {
+            data: responseData,
+            requestId: options.requestId,
+        };
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { YetterImageClient } from "./api.js";
+export * from "./types.js";
+export { yetter } from "./client.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { YetterImageClient } from "./api.js";
+export * from "./types.js";
+export { yetter } from "./client.js";

package/dist/types.d.ts

@@ -0,0 +1,89 @@
+export interface ClientOptions {
+    apiKey: string;
+    endpoint?: string;
+}
+export interface GenerateImageRequest {
+    model: string;
+    prompt: string;
+    num_inference_steps?: number;
+    seed?: number;
+}
+export interface GenerateImageResponse {
+    status: string;
+    request_id: string;
+    response_url: string;
+    status_url: string;
+    cancel_url: string;
+    queue_position: number;
+}
+export interface LogEntry {
+    message: string;
+}
+export interface GetStatusRequest {
+    url: string;
+    logs?: boolean;
+}
+export interface GetStatusResponse {
+    status: string;
+    request_id?: string;
+    response_url?: string;
+    status_url?: string;
+    cancel_url?: string;
+    queue_position?: number;
+    logs?: LogEntry[];
+}
+export interface CancelRequest {
+    url: string;
+}
+export interface CancelResponse {
+    status: string;
+    request_id?: string;
+    response_url?: string;
+    status_url?: string;
+    cancel_url?: string;
+    queue_position?: number;
+    logs?: string[];
+}
+export interface GetResponseRequest {
+    url: string;
+}
+export interface GetResponseResponse {
+    images: string[];
+    prompt: string;
+}
+export interface SubscribeOptions {
+    input: Omit<GenerateImageRequest, 'model'>;
+    logs?: boolean;
+    onQueueUpdate?: (update: GetStatusResponse) => void;
+}
+export interface SubmitQueueOptions {
+    input: Omit<GenerateImageRequest, 'model'>;
+}
+export interface GetResultOptions {
+    requestId: string;
+}
+export interface GetResultResponse {
+    data: GetResponseResponse;
+    requestId: string;
+}
+export interface StatusOptions {
+    requestId: string;
+}
+export interface StatusResponse {
+    data: GetStatusResponse;
+    requestId: string;
+}
+export interface StreamOptions {
+    input: Omit<GenerateImageRequest, 'model'>;
+}
+/**
+ * Represents an event received from the SSE stream.
+ * The `data` field is expected to be compatible with GetStatusResponse.
+ */
+export interface StreamEvent extends GetStatusResponse {
+}
+export interface YetterStream extends AsyncIterable<StreamEvent> {
+    done(): Promise<GetResponseResponse>;
+    cancel(): Promise<void>;
+    getRequestId(): string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/examples/stream.ts

@@ -0,0 +1,53 @@
+import { yetter } from "../src/client.js";
+
+async function main() {
+    const model = "ytr-ai/flux/dev";
+    console.log("\n--- Starting Stream Test ---");
+    let streamRequestId = "";
+
+    try {
+        const streamInstance = await yetter.stream(model, {
+            input: {
+                prompt: "a bioluminescent forest at night, fantasy art",
+                // You can add other parameters like seed or num_inference_steps here
+            },
+        });
+        streamRequestId = streamInstance.getRequestId();
+        console.log(`[${new Date().toLocaleTimeString()}] Stream initiated for Request ID: ${streamRequestId}`);
+
+        // Iterate over stream events
+        for await (const event of streamInstance) {
+            console.log(`[${new Date().toLocaleTimeString()}][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(`[${new Date().toLocaleTimeString()}] Stream for ${streamRequestId} finished iterating events.`);
+
+        // Wait for the final result from the done() method
+        console.log(`[${new Date().toLocaleTimeString()}] Waiting for done() on stream for ${streamRequestId}...`);
+        const result = await streamInstance.done();
+        console.log("\n--- Stream Test Final Result ---");
+        console.log(`Request ID: ${streamRequestId}`);
+        if (result.images && result.images.length > 0) {
+            console.log("Generated Images:", result.images);
+        } else {
+            console.log("No images in final result.");
+        }
+        console.log("Original Prompt:", result.prompt);
+
+    } catch (err: any) {
+        console.error(`\n--- Stream Test Failed (Request ID: ${streamRequestId || 'UNKNOWN'}) ---`);
+        console.error("Error during stream test:", err.message || err);
+        if (err.stack) {
+            console.error(err.stack);
+        }
+        process.exit(1);
+    }
+}
+
+main().catch(err => {
+    console.error("Unhandled error in main:", err);
+    process.exit(1);
+}); 

package/examples/submit.ts

@@ -0,0 +1,79 @@
+import { yetter } from "../src/client.js";
+
+async function main() {
+    const model = "ytr-ai/flux/dev";
+    // Queue Submit test
+    try {
+        console.log("\n--- Starting Queue Submit Test ---");
+        const { request_id, status, queue_position } = await yetter.queue.submit(model, {
+            input: {
+                prompt: "a fluffy white kitten playing with a yarn ball",
+            },
+        });
+
+        console.log("\n--- Queue Submit Test Result ---");
+        console.log("Request ID:", request_id);
+        console.log("Status:", status);
+        console.log("Queue Position:", queue_position);
+
+        if (request_id) {
+            console.log(`\n--- Polling for status of Request ID: ${request_id} (3-minute timeout) ---`);
+            
+            const startTime = Date.now();
+            const timeoutMilliseconds = 3 * 60 * 1000; // 3 minutes
+            const pollIntervalMilliseconds = 10 * 1000; // Poll every 10 seconds
+            let success = false;
+
+            while (Date.now() - startTime < timeoutMilliseconds) {
+                try {
+                    const statusResult = await yetter.queue.status(model, {
+                        requestId: request_id,
+                    });
+                    const currentStatus = statusResult.data.status;
+                    console.log(`[${new Date().toLocaleTimeString()}] Request ${request_id} status: ${currentStatus}, Queue Position: ${statusResult.data.queue_position}`);
+
+                    if (currentStatus === "COMPLETED") {
+                        console.log("Status is COMPLETED. Fetching final result...");
+                        const finalResult = await yetter.queue.result(model, {
+                            requestId: request_id,
+                        });
+                        console.log("\n--- Get Result Test Succeeded ---");
+                        console.log("Request ID:", finalResult.requestId);
+                        console.log("Image Data:", finalResult.data.images);
+                        console.log("Prompt:", finalResult.data.prompt);
+                        success = true;
+                        break; // Exit loop on success
+                    } else if (currentStatus === "FAILED") {
+                        console.error(`Request ${request_id} FAILED. Logs:`, statusResult.data.logs);
+                        break; // Exit loop on failure
+                    }
+                    // For other statuses (e.g., IN_QUEUE, IN_PROGRESS), continue polling
+
+                } catch (pollError: any) {
+                    console.error(`Error during status polling for ${request_id} (will retry):`, pollError.message || pollError);
+                }
+
+                if (Date.now() - startTime + pollIntervalMilliseconds >= timeoutMilliseconds) {
+                    if (!success) console.error("Timeout approaching, last poll cycle completed or error occurred.");
+                    break; // Don't wait if the next interval exceeds timeout
+                }
+                await new Promise(resolve => setTimeout(resolve, pollIntervalMilliseconds));
+            }
+
+            if (!success) {
+                console.error(`\n--- Polling Timed Out or Failed for Request ID: ${request_id} ---`);
+                console.error(`Failed to get a COMPLETED status for ${request_id} within 3 minutes.`);
+            }
+        }
+
+    } catch (err: any) {
+        console.error("\n--- Queue Submit Test Failed ---");
+        console.error("Error during queue submit:", err.message || err);
+        if (err.stack) {
+            console.error(err.stack);
+        }
+        process.exit(1);
+    }
+}
+
+main();

package/examples/subscribe.ts

@@ -0,0 +1,39 @@
+import { yetter } from "../dist/index.js";
+
+async function main() {
+    const model = "ytr-ai/flux/dev";
+    // Subscribe test
+    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);
+
+    } catch (err: any) {
+        console.error("\n--- Subscribe Test Failed ---");
+        console.error("Error during subscribe:", err.message || err);
+        if (err.stack) {
+            console.error(err.stack);
+        }
+        process.exit(1);
+    }
+}
+
+main();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@yetter/client",
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "test:submit": "node --loader ts-node/esm examples/submit.ts",
+    "test:subscribe": "node --loader ts-node/esm examples/subscribe.ts",
+    "test:stream": "node --loader ts-node/esm examples/stream.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "description": "",
+  "dependencies": {
+    "@types/eventsource": "^1.1.15",
+    "cross-fetch": "^4.1.0",
+    "event-source-polyfill": "^1.0.31",
+    "eventsource": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/event-source-polyfill": "^1.0.5",
+    "@types/node": "^22.15.23",
+    "eslint": "^9.27.0",
+    "prettier": "^3.5.3",
+    "ts-lib": "^0.0.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  }
+}

package/src/api.ts

@@ -0,0 +1,105 @@
+import fetch from "cross-fetch";
+import {
+    ClientOptions,
+    GenerateImageRequest,
+    GenerateImageResponse,
+    GetStatusRequest,
+    GetStatusResponse,
+    CancelRequest,
+    CancelResponse,
+    GetResponseRequest,
+    GetResponseResponse,
+} from "./types";
+
+export class YetterImageClient {
+    private apiKey: string;
+    private endpoint: string;
+
+    constructor(options: ClientOptions) {
+        if (!options.apiKey) {
+            throw new Error("`apiKey` is required");
+        }
+        this.apiKey = options.apiKey;
+        this.endpoint = options.endpoint || "https://api.yetter.ai";
+    }
+
+    public getApiEndpoint(): string {
+        return this.endpoint;
+    }
+
+    public async generateImage(
+        body: GenerateImageRequest
+    ): Promise<GenerateImageResponse> {
+        const url = `${this.endpoint}/${body.model}`;
+        const res = await fetch(url, {
+            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(`API error (${res.status}): ${errorText}`);
+        }
+        
+        return (await res.json()) as GenerateImageResponse;
+    }
+    
+    public async getStatus(body: GetStatusRequest): Promise<GetStatusResponse> {
+        const url = new URL(body.url);
+        if (body.logs) {
+            url.searchParams.append('logs', '1');
+        }
+        
+        const res = await fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `${this.apiKey}`,
+            },
+        });
+        
+        if (!res.ok) {
+            const errorText = await res.text();
+            throw new Error(`API error (${res.status}): ${errorText}`);
+        }
+        
+        return (await res.json()) as GetStatusResponse;
+    }
+    
+    public async cancel(body: CancelRequest): Promise<CancelResponse> {
+        const res = await fetch(body.url, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json", 
+                Authorization: `${this.apiKey}`,
+            },
+        });
+        
+        if (!res.ok) {
+            const errorText = await res.text();
+            throw new Error(`API error (${res.status}): ${errorText}`);
+        }
+        
+        return (await res.json()) as CancelResponse;
+    }
+
+    public async getResponse(body: GetResponseRequest): Promise<GetResponseResponse> {
+        const res = await fetch(body.url, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `${this.apiKey}`,
+            },
+        });
+
+        if (!res.ok) {
+            const errorText = await res.text();
+            throw new Error(`API error (${res.status}): ${errorText}`);
+        }
+        return (await res.json()) as GetResponseResponse;
+    }
+}

package/src/client.ts

@@ -0,0 +1,312 @@
+import { YetterImageClient } from "./api.js";
+import { EventSourcePolyfill } from 'event-source-polyfill';
+import {
+    GetStatusResponse,
+    GetResponseResponse,
+    SubscribeOptions,
+    GenerateImageResponse,
+    SubmitQueueOptions,
+    GetResultOptions,
+    GetResultResponse,
+    StatusOptions,
+    StatusResponse,
+    StreamOptions,
+    StreamEvent,
+    YetterStream,
+} from "./types.js";
+
+export class yetter {
+    public static async subscribe(
+        model: string,
+        options: SubscribeOptions
+    ): Promise<GetResponseResponse> {
+        if (!process.env.YTR_API_KEY) {
+            throw new Error("YTR_API_KEY is not set");
+        }
+        const client = new YetterImageClient({
+            apiKey: process.env.YTR_API_KEY,
+        });
+
+        const generateResponse = await client.generateImage({
+            model: model,
+            ...options.input,
+        });
+
+        let status = generateResponse.status;
+        let lastStatusResponse: GetStatusResponse | undefined;
+
+        const startTime = Date.now();
+        const timeoutMilliseconds = 30 * 60 * 1000; // 30 minutes
+
+        while (status !== "COMPLETED" && status !== "FAILED") {
+            if (Date.now() - startTime > timeoutMilliseconds) {
+                console.warn(`Subscription timed out after 30 minutes for request ID: ${generateResponse.request_id}. Attempting to cancel.`);
+                try {
+                    await client.cancel({ url: generateResponse.cancel_url });
+                    console.log(`Cancellation request sent for request ID: ${generateResponse.request_id}.`);
+                } catch (cancelError: any) {
+                    console.error(`Failed to cancel request ID: ${generateResponse.request_id} after timeout:`, cancelError.message || cancelError);
+                }
+                throw new Error(`Subscription timed out after 30 minutes for request ID: ${generateResponse.request_id}.`);
+            }
+
+            try {
+                lastStatusResponse = await client.getStatus({
+                    url: generateResponse.status_url,
+                    logs: options.logs,
+                });
+                status = lastStatusResponse.status;
+
+                if (options.onQueueUpdate) {
+                    options.onQueueUpdate(lastStatusResponse);
+                }
+            } catch (error) {
+                console.error("Error during status polling:", error);
+                throw error; 
+            }
+        }
+
+        if (status === "FAILED") {
+            const errorMessage = lastStatusResponse?.logs?.map(log => log.message).join("\n") || "Image generation failed.";
+            throw new Error(errorMessage);
+        }
+
+        const finalResponse = await client.getResponse({
+            url: generateResponse.response_url,
+        });
+
+        return finalResponse;
+    }
+
+    public static queue = {
+        submit: async (
+            model: string,
+            options: SubmitQueueOptions
+        ): Promise<GenerateImageResponse> => {
+            if (!process.env.YTR_API_KEY) {
+                throw new Error("YTR_API_KEY is not set");
+            }
+            const client = new YetterImageClient({
+                apiKey: process.env.YTR_API_KEY,
+            });
+
+            const generateResponse = await client.generateImage({
+                model: model,
+                ...options.input,
+            });
+
+            return generateResponse;
+        },
+
+        status: async (
+            model: string,
+            options: StatusOptions
+        ): Promise<StatusResponse> => {
+            if (!process.env.YTR_API_KEY) {
+                throw new Error("YTR_API_KEY is not set");
+            }
+            const client = new YetterImageClient({
+                apiKey: process.env.YTR_API_KEY,
+            });
+
+            const endpoint = client.getApiEndpoint();
+
+            const statusUrl = `${endpoint}/${model}/requests/${options.requestId}/status`;
+
+            const statusData = await client.getStatus({ url: statusUrl });
+
+            return {
+                data: statusData,
+                requestId: options.requestId,
+            };
+        },
+
+        result: async (
+            model: string,
+            options: GetResultOptions
+        ): Promise<GetResultResponse> => {
+            if (!process.env.YTR_API_KEY) {
+                throw new Error("YTR_API_KEY is not set");
+            }
+            const client = new YetterImageClient({
+                apiKey: process.env.YTR_API_KEY,
+            });
+
+            const endpoint = client.getApiEndpoint();
+
+            const responseUrl = `${endpoint}/${model}/requests/${options.requestId}`;
+
+            const responseData = await client.getResponse({ url: responseUrl });
+
+            return {
+                data: responseData,
+                requestId: options.requestId,
+            };
+        }
+    };
+
+    public static async stream(
+        model: string,
+        options: StreamOptions
+    ): Promise<YetterStream> {
+        if (!process.env.YTR_API_KEY) {
+            throw new Error("YTR_API_KEY is not set");
+        }
+        const apiClient = new YetterImageClient({
+            apiKey: process.env.YTR_API_KEY,
+        });
+
+        const initialApiResponse = await apiClient.generateImage({
+            model: model,
+            ...options.input,
+        });
+
+        const requestId = initialApiResponse.request_id;
+        const responseUrl = initialApiResponse.response_url;
+        const cancelUrl = initialApiResponse.cancel_url;
+        const sseStreamUrl = `${apiClient.getApiEndpoint()}/${model}/requests/${requestId}/status/stream`;
+
+        let eventSource: EventSource;
+        let streamEnded = false;
+
+        // Setup the promise for the done() method
+        let resolveDonePromise: (value: GetResponseResponse) => void;
+        let rejectDonePromise: (reason?: any) => void;
+        const donePromise = new Promise<GetResponseResponse>((resolve, reject) => {
+            resolveDonePromise = resolve;
+            rejectDonePromise = reject;
+        });
+
+        const controller = {
+            // This will be used by the async iterator to pull events
+            // It needs a way to buffer events or signal availability
+            events: [] as StreamEvent[],
+            resolvers: [] as Array<(value: IteratorResult<StreamEvent, any>) => void>,
+            isClosed: false,
+            push(event: StreamEvent) {
+                if (this.isClosed) return;
+                if (this.resolvers.length > 0) {
+                    this.resolvers.shift()!({ value: event, done: false });
+                } else {
+                    this.events.push(event);
+                }
+                // Check for terminal events to resolve/reject the donePromise
+                if (event.status === "COMPLETED") {
+                    streamEnded = true;
+                    apiClient.getResponse({ url: responseUrl })
+                        .then(resolveDonePromise)
+                        .catch(rejectDonePromise)
+                        .finally(() => this.close());
+                } else if (event.status === "FAILED") {
+                    streamEnded = true;
+                    rejectDonePromise(new Error(event.logs?.map(l => l.message).join('\n') || `Stream reported FAILED for ${requestId}`));
+                    this.close();
+                }
+            },
+            error(err: any) {
+                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
+                } else {
+                    console.warn("SSE 'onerror' event after stream was considered ended (COMPLETED/FAILED). This error will not alter the done() promise.", err);
+                }
+
+                streamEnded = true; // Ensure it's marked as ended
+                if (this.resolvers.length > 0) {
+                    this.resolvers.shift()!({ value: undefined, done: true }); // Signal error to iterator consumer
+                }
+                this.close(); // Proceed to close EventSource etc.
+            },
+            close() {
+                if (this.isClosed) return;
+                this.isClosed = true;
+                this.resolvers.forEach(resolve => resolve({ value: undefined, done: true }));
+                this.resolvers = [];
+                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(() => { // check if it's already settled
+                        if (!streamEnded) { // If not explicitly completed or failed
+                           rejectDonePromise(new Error("Stream closed prematurely or unexpectedly."));
+                        }
+                    });
+                }, 100);
+            },
+            next(): Promise<IteratorResult<StreamEvent, any>> {
+                if (this.events.length > 0) {
+                    return Promise.resolve({ value: this.events.shift()!, done: false });
+                }
+                if (this.isClosed) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise(resolve => this.resolvers.push(resolve));
+            }
+        };
+
+        eventSource = new EventSourcePolyfill(sseStreamUrl, {
+            headers: { 'Authorization': `${process.env.YTR_API_KEY}` }
+        } as any);
+
+        eventSource.onopen = (event: Event) => {
+            console.log("SSE Connection Opened:", event);
+        };
+
+        eventSource.addEventListener('data', (event: MessageEvent) => {
+            console.log("SSE 'data' event received, raw data:", event.data);
+            try {
+                const statusData: GetStatusResponse = JSON.parse(event.data as string);
+                controller.push(statusData as StreamEvent);
+            } catch (e: any) {
+                console.error("Error parsing SSE 'data' event:", e, "Raw data:", event.data);
+                controller.error(new Error(`Error parsing SSE 'data' event: ${e.message}`));
+            }
+        });
+
+        eventSource.addEventListener('done', (event: MessageEvent) => {
+            console.log("SSE 'done' event received, raw data:", event.data);
+            controller.close();
+        });
+
+        eventSource.onerror = (err: Event | MessageEvent) => { 
+            console.error("SSE Connection Error (onerror):", err);
+            controller.error(err);
+        };
+        
+        // Handle if API immediately returns a terminal status in initialApiResponse (e.g. already completed/failed)
+        if (initialApiResponse.status === "COMPLETED"){
+            controller.push(initialApiResponse as any as StreamEvent);
+        } else if (initialApiResponse.status === "FAILED"){
+            controller.push(initialApiResponse as any as StreamEvent);
+        }
+
+        return {
+            async *[Symbol.asyncIterator]() {
+                while (!controller.isClosed || controller.events.length > 0) {
+                    const event = await controller.next();
+                    if (event.done) break;
+                    yield event.value;
+                }
+            },
+            done: () => donePromise,
+            cancel: async () => {
+                controller.close();
+                try {
+                    await apiClient.cancel({ url: cancelUrl });
+                    console.log(`Stream for ${requestId} - underlying request cancelled.`);
+                } catch (e: any) {
+                    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,
+        };
+    }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { YetterImageClient } from "./api.js";
+export * from "./types.js";
+export { yetter } from "./client.js";

package/src/types.ts

@@ -0,0 +1,112 @@
+export interface ClientOptions {
+    apiKey: string;
+    endpoint?: string;
+}
+
+export interface GenerateImageRequest {
+    model: string;
+    prompt: string;
+    num_inference_steps?: number;
+    seed?: number;
+}
+
+export interface GenerateImageResponse {
+    status: string;
+    request_id: string;
+    response_url: string;
+    status_url: string;
+    cancel_url: string;
+    queue_position: number;
+}
+
+export interface LogEntry {
+    message: string;
+    // Add other potential log fields here, e.g., timestamp, level
+}
+
+export interface GetStatusRequest {
+    url: string;
+    logs?: boolean;
+}
+
+export interface GetStatusResponse {
+    status: string;
+    request_id?: string;
+    response_url?: string;
+    status_url?: string;
+    cancel_url?: string;
+    queue_position?: number;
+    logs?: LogEntry[];
+}
+
+export interface CancelRequest {
+    url: string;
+}
+
+export interface CancelResponse {
+    status: string;
+    request_id?: string;
+    response_url?: string;
+    status_url?: string;
+    cancel_url?: string;
+    queue_position?: number;
+    logs?: string[];
+}
+
+export interface GetResponseRequest {
+    url: string;
+}
+
+export interface GetResponseResponse {
+    images: string[];
+    prompt: string;
+}
+
+export interface SubscribeOptions {
+  input: Omit<GenerateImageRequest, 'model'>; // model is a direct param to subscribe
+  logs?: boolean;
+  onQueueUpdate?: (update: GetStatusResponse) => void;
+}
+
+export interface SubmitQueueOptions {
+  input: Omit<GenerateImageRequest, 'model'>;
+}
+
+export interface GetResultOptions {
+  requestId: string;
+}
+
+export interface GetResultResponse {
+  data: GetResponseResponse;
+  requestId: string;
+}
+
+export interface StatusOptions {
+  requestId: string;
+}
+
+export interface StatusResponse {
+  data: GetStatusResponse;
+  requestId: string;
+}
+
+// --- Stream Types ---
+export interface StreamOptions {
+    input: Omit<GenerateImageRequest, 'model'>;
+    // logs?: boolean; // Optional: if you want to request logs via stream if API supports it
+}
+
+/**
+ * Represents an event received from the SSE stream.
+ * The `data` field is expected to be compatible with GetStatusResponse.
+ */
+export interface StreamEvent extends GetStatusResponse { // SSE events directly reflect status updates
+    // type: string; // Could be 'status', 'error', 'open', etc. if the stream sends typed messages.
+                   // If the stream ONLY sends GetStatusResponse JSON, this might not be needed.
+}
+
+export interface YetterStream extends AsyncIterable<StreamEvent> {
+    done(): Promise<GetResponseResponse>; // Resolves with the final image data
+    cancel(): Promise<void>; // Cancels the stream and attempts to cancel the underlying API request
+    getRequestId(): string; // Helper to get the request ID associated with the stream
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
+}