@hautechai/sdk 1.0.3 → 1.0.5

package/dist/sdk/index.js

@@ -0,0 +1,69 @@
+import access from './access';
+import accounts from './accounts';
+import balances from './balances';
+import collections from './collections';
+import groups from './groups';
+import images from './images';
+import { decodeJwt } from 'jose';
+import operations from './operations';
+import pipelines from './pipelines';
+import stacks from './stacks';
+import storage from './storage';
+import utils from './utils';
+import { OperationsListener } from './listeners';
+import { getAPI, getBaseUrl } from './api';
+import { OperationsApi } from '../autogenerated';
+import poses from './poses';
+import videos from './videos';
+const replaceProtocol = (url, protocol) => {
+    const parsed = new URL(url);
+    parsed.protocol = protocol;
+    return parsed.toString();
+};
+export const createSDK = (options) => {
+    let token = undefined;
+    const authToken = async () => {
+        if (token) {
+            const decoded = decodeJwt(token);
+            const currentTime = Math.floor(Date.now() / 1000);
+            if (decoded.exp && decoded.exp > currentTime)
+                return token;
+        }
+        token = await options.authToken();
+        return token;
+    };
+    const optionsWithTokenRefresher = { ...options, authToken };
+    const operationsListener = new OperationsListener({
+        ws: (options.useWebsocket ?? true)
+            ? {
+                endpoint: (() => {
+                    const baseUrl = getBaseUrl(options);
+                    return replaceProtocol(baseUrl, baseUrl.startsWith('https') ? 'wss' : 'ws');
+                })(),
+                token: authToken,
+            }
+            : null,
+        // TODO: Refactor the API initialization
+        operations: () => getAPI(OperationsApi, optionsWithTokenRefresher),
+        allowPollingFallback: options.allowPollingFallback ?? true,
+    });
+    operationsListener.subscribe();
+    return {
+        access: access(optionsWithTokenRefresher),
+        accounts: accounts(optionsWithTokenRefresher),
+        balances: balances(optionsWithTokenRefresher),
+        collections: collections(optionsWithTokenRefresher),
+        groups: groups(optionsWithTokenRefresher),
+        images: images(optionsWithTokenRefresher),
+        videos: videos(optionsWithTokenRefresher),
+        operations: operations(optionsWithTokenRefresher, operationsListener),
+        pipelines: pipelines(optionsWithTokenRefresher),
+        stacks: stacks(optionsWithTokenRefresher),
+        storage: storage(optionsWithTokenRefresher),
+        utils: utils(optionsWithTokenRefresher),
+        poses: poses(optionsWithTokenRefresher),
+        close: async () => {
+            await operationsListener.close();
+        },
+    };
+};

package/dist/sdk/listeners/index.d.ts

@@ -0,0 +1,28 @@
+import { OperationEntity, OperationsApi } from '../../autogenerated';
+import { w3cwebsocket as WebSocketClient } from 'websocket';
+export declare class OperationsListener {
+    useWebsocket: {
+        endpoint: string;
+        token: () => string | Promise<string>;
+    } | null;
+    ws: WebSocketClient | null;
+    operations: () => Promise<OperationsApi>;
+    allowPollingFallback: boolean;
+    constructor({ ws, operations, allowPollingFallback, }: {
+        ws: {
+            endpoint: string;
+            token: () => string | Promise<string>;
+        } | null;
+        operations: () => Promise<OperationsApi>;
+        allowPollingFallback: boolean;
+    });
+    operationsStore: Record<string, OperationEntity>;
+    getOperation(id: string): Promise<OperationEntity | null>;
+    private updateOperation;
+    subscribe(): Promise<void>;
+    onOpen(): void;
+    websocketEnabled(): boolean;
+    onMessage(msg: string): void;
+    onClose(number: number, reason: string): void;
+    close(): Promise<void>;
+}

package/dist/sdk/listeners/index.js

@@ -0,0 +1,104 @@
+import { w3cwebsocket as WebSocketClient } from 'websocket';
+import { HautechError } from '../errors';
+// This is pretty much a dirty solution until we need to rework this part.
+export class OperationsListener {
+    constructor({ ws, operations, allowPollingFallback = false, }) {
+        this.useWebsocket = null;
+        this.ws = null;
+        this.operationsStore = {};
+        if (!ws)
+            allowPollingFallback = true;
+        if (ws) {
+            this.useWebsocket = {
+                endpoint: ws?.endpoint,
+                token: ws?.token,
+            };
+        }
+        this.operations = operations;
+        this.allowPollingFallback = allowPollingFallback;
+    }
+    async getOperation(id) {
+        const fallbackToPolling = this.allowPollingFallback && !(this.ws?.readyState === WebSocketClient.OPEN);
+        if (!this.operationsStore[id] || fallbackToPolling) {
+            const api = await this.operations();
+            const operation = await api.operationsControllerGetOperationV1(id);
+            if (operation.status == 200)
+                this.updateOperation(id, operation.data);
+        }
+        return this.operationsStore[id] || null;
+    }
+    updateOperation(id, operation) {
+        const stored = this.operationsStore[id];
+        if (!stored || stored.updatedAt < operation.updatedAt) {
+            this.operationsStore[id] = operation;
+        }
+    }
+    async subscribe() {
+        if (!this.useWebsocket)
+            return;
+        try {
+            const token = await this.useWebsocket.token();
+            this.ws = new WebSocketClient(this.useWebsocket.endpoint, ['1', token]);
+            this.ws.onopen = () => {
+                this.onOpen();
+            };
+            this.ws.onerror = (err) => {
+                console.error('HautechAI SDK encountered a WebSocket error: ', err);
+            };
+            this.ws.onmessage = (msg) => {
+                if (typeof msg.data === 'string') {
+                    this.onMessage(msg.data);
+                }
+                else if (msg.data instanceof Buffer) {
+                    this.onMessage(msg.data.toString('utf8'));
+                }
+                else {
+                    this.onMessage(Buffer.from(msg.data).toString('utf8'));
+                }
+            };
+            this.ws.onclose = (event) => {
+                this.onClose(event.code, event.reason);
+            };
+        }
+        catch (err) {
+            throw new HautechError(`SDK failed to open websocket: ${err}`);
+        }
+    }
+    onOpen() {
+        if (!this.ws)
+            throw new HautechError('Semantics error: this is a bug.');
+        this.ws.send(JSON.stringify({
+            event: 'subscribe',
+            data: {
+                channel: 'own_resources',
+            },
+        }));
+    }
+    websocketEnabled() {
+        return this.ws?.readyState === WebSocketClient.OPEN;
+    }
+    onMessage(msg) {
+        if (!this.ws)
+            throw new HautechError('Semantics error: this is a bug.');
+        const { event, data } = JSON.parse(msg);
+        switch (event) {
+            case 'subscription:created':
+                break;
+            case 'operation:created':
+            case 'operation:updated':
+                this.updateOperation(data.id, data);
+                break;
+        }
+    }
+    onClose(number, reason) {
+        if (!this.ws)
+            throw new HautechError('Semantics error: this is a bug.');
+        // Reset dirty state.
+        this.operationsStore = {};
+        this.ws = null;
+    }
+    async close() {
+        this.ws?.close();
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+}

package/dist/sdk/operations/index.d.ts

@@ -0,0 +1,199 @@
+import { AnimateKling16ProV1Input, AnimateKling16ProV1Response, AnimateKling21V1Input, AnimateKling21V1Response, CompositeV1Input, CompositeV1Response, ContrastV1Input, ContrastV1Response, CropV1Input, CropV1Response, CutV1Input, CutV1Response, EditFluxKontextDevV1Input, EditFluxKontextDevV1Response, GiseleVtonV1Input, GPTV1Input, GptV1Response, GPTV2Input, GptV2Response, HauteLindaV1Response, HauteNaomiV1Response, ImagineKateV1Response, KateImagineV1Input, KateInpaintV1Input, LindaHauteV1Input, MathV1Input, MathV1Response, NaomiHauteV1Input, NegateImageV1Input, NegateImageV1Response, NoiseV1Input, NoiseV1Response, ObjectDetectionV1Input, ObjectDetectionV1Response, OperationEntity, OperationEntityStatusEnum, PoseEstimationV1Input, PoseEstimationV1Response, ResizeV1Input, ResizeV1Response, SegmentAnythingEmbeddingsV1Input, SegmentAnythingEmbeddingsV1Response, SegmentAnythingMaskV1Input, SegmentAnythingMaskV1Response, StringsTemplateV1Input, StringsTemplateV1Response, TranslateV1Input, TranslateV1Response, UpscaleV1Input, UpscaleV1Response, VtonGiseleV1Response } from '../../autogenerated';
+import { ListProps, ListResponse, SDKOptions } from '../../types';
+import { OperationMetadata } from '../index';
+import { OperationsListener } from '../listeners';
+import { AddMetadata } from '../utils';
+type OperationEntityWithMetadata = AddMetadata<OperationEntity, OperationMetadata>;
+type Waited<T extends OperationEntityWithMetadata> = T & ({
+    status: typeof OperationEntityStatusEnum.Failed;
+    output: null;
+} | {
+    status: typeof OperationEntityStatusEnum.Pending;
+    output: null;
+} | {
+    status: typeof OperationEntityStatusEnum.Finished;
+    output: NonNullable<T['output']>;
+});
+declare const operations: (options: SDKOptions, operationsListener: OperationsListener) => {
+    run: {
+        animate: {
+            kling_1_6_pro: {
+                v1: (props: {
+                    input: AnimateKling16ProV1Input;
+                    metadata?: any;
+                }) => Promise<AnimateKling16ProV1Response>;
+            };
+            kling_2_1: {
+                v1: (props: {
+                    input: AnimateKling21V1Input;
+                    metadata?: any;
+                }) => Promise<AnimateKling21V1Response>;
+            };
+        };
+        edit: {
+            flux_kontext_dev: {
+                v1: (props: {
+                    input: EditFluxKontextDevV1Input;
+                    metadata?: any;
+                }) => Promise<EditFluxKontextDevV1Response>;
+            };
+        };
+        haute: {
+            linda: {
+                v1: (props: {
+                    input: LindaHauteV1Input;
+                    metadata?: any;
+                }) => Promise<HauteLindaV1Response>;
+            };
+            naomi: {
+                v1: (props: {
+                    input: NaomiHauteV1Input;
+                    metadata?: any;
+                }) => Promise<HauteNaomiV1Response>;
+            };
+        };
+        inpaint: {
+            kate: {
+                v1: (props: {
+                    input: KateInpaintV1Input;
+                    metadata?: any;
+                }) => Promise<ImagineKateV1Response>;
+            };
+        };
+        gpt: {
+            v1: (props: {
+                input: GPTV1Input;
+                metadata?: any;
+            }) => Promise<GptV1Response>;
+            v2: (props: {
+                input: GPTV2Input;
+                metadata?: any;
+            }) => Promise<GptV2Response>;
+        };
+        math: {
+            v1: (props: {
+                input: MathV1Input;
+                metadata?: any;
+            }) => Promise<MathV1Response>;
+        };
+        translate: {
+            v1: (props: {
+                input: TranslateV1Input;
+                metadata?: any;
+            }) => Promise<TranslateV1Response>;
+        };
+        imagine: {
+            kate: {
+                v1: (props: {
+                    input: KateImagineV1Input;
+                    metadata?: any;
+                }) => Promise<ImagineKateV1Response>;
+            };
+        };
+        upscale: {
+            v1: (props: {
+                input: UpscaleV1Input;
+                metadata?: any;
+            }) => Promise<UpscaleV1Response>;
+        };
+        objectDetection: {
+            v1: (props: {
+                input: ObjectDetectionV1Input;
+                metadata?: any;
+            }) => Promise<ObjectDetectionV1Response>;
+        };
+        segmentAnything: {
+            embeddings: {
+                v1: (props: {
+                    input: SegmentAnythingEmbeddingsV1Input;
+                    metadata?: any;
+                }) => Promise<SegmentAnythingEmbeddingsV1Response>;
+            };
+            mask: {
+                v1: (props: {
+                    input: SegmentAnythingMaskV1Input;
+                    metadata?: any;
+                }) => Promise<SegmentAnythingMaskV1Response>;
+            };
+        };
+        poseEstimation: {
+            v1: (props: {
+                input: PoseEstimationV1Input;
+                metadata?: any;
+            }) => Promise<PoseEstimationV1Response>;
+        };
+        cut: {
+            v1: (props: {
+                input: CutV1Input;
+                metadata?: any;
+            }) => Promise<CutV1Response>;
+        };
+        crop: {
+            v1: (props: {
+                input: CropV1Input;
+                metadata?: any;
+            }) => Promise<CropV1Response>;
+        };
+        noise: {
+            v1: (props: {
+                input: NoiseV1Input;
+                metadata?: any;
+            }) => Promise<NoiseV1Response>;
+        };
+        contrast: {
+            v1: (props: {
+                input: ContrastV1Input;
+                metadata?: any;
+            }) => Promise<ContrastV1Response>;
+        };
+        composite: {
+            v1: (props: {
+                input: CompositeV1Input;
+                metadata?: any;
+            }) => Promise<CompositeV1Response>;
+        };
+        vton: {
+            gisele: {
+                v1: (props: {
+                    input: GiseleVtonV1Input;
+                    metadata?: any;
+                }) => Promise<VtonGiseleV1Response>;
+            };
+        };
+        negateImage: {
+            v1: (props: {
+                input: NegateImageV1Input;
+                metadata?: any;
+            }) => Promise<NegateImageV1Response>;
+        };
+        resize: {
+            v1: (props: {
+                input: ResizeV1Input;
+                metadata?: any;
+            }) => Promise<ResizeV1Response>;
+        };
+        strings: {
+            template: {
+                v1: (props: {
+                    input: StringsTemplateV1Input;
+                    metadata?: any;
+                }) => Promise<StringsTemplateV1Response>;
+            };
+        };
+    };
+    get: (props: {
+        id: string;
+    }) => Promise<OperationEntityWithMetadata | undefined>;
+    getMany: (props: {
+        ids: string[];
+    }) => Promise<OperationEntityWithMetadata[]>;
+    list: (props?: ListProps) => Promise<ListResponse<OperationEntityWithMetadata>>;
+    updateMetadata: (props: {
+        id: string;
+        metadata?: any;
+    }) => Promise<void>;
+    wait: <T extends OperationEntityWithMetadata | {
+        id: string;
+    }, N extends number | undefined = undefined>(props: T, timeoutMs?: N) => Promise<Waited<T extends OperationEntityWithMetadata ? T : OperationEntityWithMetadata> | (N extends undefined ? never : null)>;
+};
+export default operations;

package/dist/sdk/operations/index.js

@@ -0,0 +1,133 @@
+import { OperationsApi, } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+import { transformToListResponse } from '../transformers';
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const operations = (options, operationsListener) => {
+    const api = useAutogeneratedAPI({ API: OperationsApi, options });
+    const createOperation = (callMethod) => (props) => api.call({ run: (methods) => callMethod(methods, props) });
+    return {
+        run: {
+            animate: {
+                kling_1_6_pro: {
+                    v1: createOperation((methods, props) => methods.operationsControllerRunAnimateKling16ProV1V1(props)),
+                },
+                kling_2_1: {
+                    v1: createOperation((methods, props) => methods.operationsControllerRunAnimateKling21V1V1(props)),
+                },
+            },
+            edit: {
+                flux_kontext_dev: {
+                    v1: createOperation((methods, props) => methods.operationsControllerRunEditFluxKontextDevV1V1(props)),
+                },
+            },
+            haute: {
+                linda: {
+                    v1: createOperation((methods, props) => methods.operationsControllerRunHauteLindaV1V1(props)),
+                },
+                naomi: {
+                    v1: createOperation((methods, props) => methods.operationsControllerRunHauteNaomiV1V1(props)),
+                },
+            },
+            inpaint: {
+                kate: {
+                    v1: createOperation((methods, props) => methods.operationsControllerRunInpaintKateV1V1(props)),
+                },
+            },
+            gpt: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunGptV1V1(props)),
+                v2: createOperation((methods, props) => methods.operationsControllerRunGptV2V1(props)),
+            },
+            math: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunMathV1V1(props)),
+            },
+            translate: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunTranslateV1V1(props)),
+            },
+            imagine: {
+                kate: {
+                    v1: createOperation((methods, props) => methods.operationsControllerRunImagineKateV1V1(props)),
+                },
+            },
+            upscale: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunUpscaleV1V1(props)),
+            },
+            objectDetection: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunObjectDetectionV1V1(props)),
+            },
+            segmentAnything: {
+                embeddings: {
+                    v1: createOperation((methods, props) => methods.operationsControllerRunSegmentAnythingEmbeddingsV1V1(props)),
+                },
+                mask: {
+                    v1: createOperation((methods, props) => methods.operationsControllerRunSegmentAnythingMaskV1V1(props)),
+                },
+            },
+            poseEstimation: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunPoseEstimationV1V1(props)),
+            },
+            cut: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunCutV1V1(props)),
+            },
+            crop: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunCropV1V1(props)),
+            },
+            noise: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunNoiseV1V1(props)),
+            },
+            contrast: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunContrastV1V1(props)),
+            },
+            composite: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunCompositeV1V1(props)),
+            },
+            vton: {
+                gisele: {
+                    v1: createOperation((methods, props) => methods.operationsControllerRunVtonGiseleV1V1(props)),
+                },
+            },
+            negateImage: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunNegateImageV1V1(props)),
+            },
+            resize: {
+                v1: createOperation((methods, props) => methods.operationsControllerRunResizeV1V1(props)),
+            },
+            strings: {
+                template: {
+                    v1: createOperation((methods, props) => methods.operationsControllerRunStringsTemplateV1V1(props)),
+                },
+            },
+        },
+        get: (props) => api.callWithReturningUndefinedOn404({
+            run: (methods) => methods.operationsControllerGetOperationV1(props.id),
+        }),
+        getMany: (props) => api.call({
+            run: (methods) => methods.operationsControllerGetOperationsV1({ ids: props.ids }),
+        }),
+        list: (props = {}) => api.call({
+            run: (methods) => methods.operationsControllerListOperationsV1(props.orderBy, props.limit, props.cursor),
+            transform: transformToListResponse,
+        }),
+        updateMetadata: async (props) => api.call({
+            run: (methods) => methods.operationsControllerUpdateMetadataV1(props.id, { overwrite: props.metadata }),
+        }),
+        wait: async (props, timeoutMs) => {
+            const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
+            const delay = operationsListener.websocketEnabled() ? 50 : 1000;
+            const poll = async (id) => {
+                const operation = await operationsListener.getOperation(id);
+                if (operation?.status !== 'pending')
+                    return operation;
+                return null;
+            };
+            while (!deadline || Date.now() < deadline) {
+                const polled = await poll(props.id);
+                if (polled)
+                    return polled;
+                await sleep(delay);
+            }
+            //@ts-expect-error - can't be reached if timeoutMs is defined.
+            return null;
+        },
+    };
+};
+export default operations;