@yetter/client 0.0.11 → 0.0.13

package/src/client.ts

@@ -1,338 +0,0 @@
-import { YetterImageClient } from "./api.js";
-import { EventSourcePolyfill } from 'event-source-polyfill';
-import {
-    ClientOptions,
-    GetStatusResponse,
-    GetResponseResponse,
-    SubscribeOptions,
-    GenerateResponse,
-    SubmitQueueOptions,
-    GetResultOptions,
-    GetResultResponse,
-    StatusOptions,
-    StatusResponse,
-    StreamOptions,
-    StreamEvent,
-    YetterStream,
-} from "./types.js";
-
-export class yetter {
-    private static apiKey: string = 'Key ' + (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) {
-            if (options.is_bearer) {
-                yetter.apiKey = 'Bearer ' + options.apiKey;
-            } else {
-                yetter.apiKey = 'Key ' + options.apiKey;
-            }
-        }
-        if (options.endpoint) {
-            yetter.endpoint = options.endpoint;
-        }
-    }
-
-    public static async subscribe(
-        model: string,
-        options: SubscribeOptions
-    ): Promise<GetResponseResponse> {
-        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: yetter.apiKey,
-            endpoint: yetter.endpoint
-        });
-
-        const generateResponse = await client.generate({
-            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<GenerateResponse> => {
-            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: yetter.apiKey,
-                endpoint: yetter.endpoint
-            });
-
-            const generateResponse = await client.generate({
-                model: model,
-                ...options.input,
-            });
-
-            return generateResponse;
-        },
-
-        status: async (
-            model: string,
-            options: StatusOptions
-        ): Promise<StatusResponse> => {
-            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: yetter.apiKey,
-                endpoint: yetter.endpoint
-            });
-
-            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 (!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: yetter.apiKey,
-                endpoint: yetter.endpoint
-            });
-
-            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 (!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: yetter.apiKey,
-            endpoint: yetter.endpoint
-        });
-
-        const initialApiResponse = await client.generate({
-            model: model,
-            ...options.input,
-        });
-        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: 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;
-                    client.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': `${yetter.apiKey}` },
-        } 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) => { 
-            const message = (err as any)?.error?.message || (err as any)?.message || '';
-            const isIdleTimeout = typeof message === 'string' && message.includes('No activity within') && message.includes('Reconnecting');
-            if (isIdleTimeout) {
-                console.warn("SSE idle timeout; letting EventSource auto-reconnect.", err);
-                return;
-            }
-            console.warn("SSE Connection Error (onerror) - will allow auto-reconnect:", 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 client.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

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

package/src/types.ts

@@ -1,116 +0,0 @@
-export interface ClientOptions {
-    apiKey: string;
-    endpoint?: string;
-    is_bearer?: boolean;
-    promptEnhancerModel?: string;
-}
-
-export interface LoraWeight {
-    path: string;
-    scale?: number;
-}
-
-export interface GenerateRequest {
-    [key: string]: any;
-}
-
-export interface GenerateResponse {
-    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[] | Record<string, any>[];
-    prompt: string;
-}
-
-export interface SubscribeOptions {
-  input: Omit<GenerateRequest, 'model'>; // model is a direct param to subscribe
-  logs?: boolean;
-  onQueueUpdate?: (update: GetStatusResponse) => void;
-}
-
-export interface SubmitQueueOptions {
-  input: Omit<GenerateRequest, '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<GenerateRequest, '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

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