@decartai/sdk 0.0.68 → 0.1.1

package/dist/realtime/stream-session.js

@@ -0,0 +1,257 @@
+import { createConsoleLogger } from "../utils/logger.js";
+import { REALTIME_CONFIG } from "./config-realtime.js";
+import { InitialStateGate } from "./initial-state-gate.js";
+import { MediaChannel } from "./media-channel.js";
+import { SignalingChannel } from "./signaling-channel.js";
+import mitt from "mitt";
+import pRetry, { AbortError } from "p-retry";
+//#region src/realtime/stream-session.ts
+function encodeSubscribeToken(roomName) {
+	return btoa(JSON.stringify({ room_name: roomName }));
+}
+function getInitialImageSizeKb(image) {
+	if (!image) return null;
+	const commaIdx = image.indexOf(",");
+	const base64 = commaIdx >= 0 && image.startsWith("data:") ? image.slice(commaIdx + 1) : image;
+	const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+	const bytes = Math.floor(base64.length * 3 / 4) - padding;
+	return Math.max(0, Math.round(bytes / 1024));
+}
+var StreamSession = class {
+	signaling;
+	media;
+	events = mitt();
+	state = "disconnected";
+	queue = null;
+	disposed = false;
+	currentAttempt = 0;
+	initialStateGate = new InitialStateGate();
+	logger;
+	constructor(config) {
+		this.config = config;
+		this.logger = config.logger ?? createConsoleLogger("warn");
+		this.createTransport();
+	}
+	on(event, handler) {
+		this.events.on(event, handler);
+	}
+	off(event, handler) {
+		this.events.off(event, handler);
+	}
+	getStatus() {
+		return {
+			connection: this.state,
+			queue: this.queue
+		};
+	}
+	getConnectionState() {
+		return this.state;
+	}
+	isConnected() {
+		return this.state === "connected" || this.state === "generating";
+	}
+	async connect() {
+		this.disposed = false;
+		const attempt = ++this.currentAttempt;
+		this.setState("connecting");
+		this.logger.info("realtime connect: starting", { attemptCycle: attempt });
+		try {
+			await pRetry(() => this.runOneConnect(attempt), this.retryOptionsFor(attempt));
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.logger.error("realtime connect: exhausted all retries", { error: message });
+			if (this.currentAttempt === attempt && !this.disposed) this.setState("disconnected");
+			throw error;
+		}
+	}
+	async sendPrompt(text, opts) {
+		this.assertConnected();
+		return this.signaling.sendPrompt(text, opts);
+	}
+	async setImage(payload, opts) {
+		this.assertConnected();
+		return this.signaling.setImage(payload, opts);
+	}
+	disconnect() {
+		this.disposed = true;
+		this.tearDown();
+		this.setState("disconnected");
+	}
+	assertConnected() {
+		if (!this.isConnected()) throw new Error(`Cannot send message: connection is ${this.state}`);
+	}
+	retryOptionsFor(attempt) {
+		return {
+			...REALTIME_CONFIG.session.retry,
+			onFailedAttempt: (_error) => {
+				this.tearDown();
+			},
+			shouldRetry: (error) => {
+				if (this.disposed || this.currentAttempt !== attempt) return false;
+				const msg = error.message.toLowerCase();
+				const permanent = REALTIME_CONFIG.session.permanentErrorSubstrings.some((err) => msg.includes(err));
+				if (permanent) this.logger.error("realtime connect: permanent error, not retrying", { error: error.message });
+				return !permanent;
+			}
+		};
+	}
+	async runOneConnect(attempt) {
+		if (this.disposed || this.currentAttempt !== attempt) throw new AbortError("Stale connect attempt");
+		try {
+			this.resetHandshakeState();
+			const initialState = this.getInitialState();
+			this.config.observability?.beginConnectionBreakdown(attempt, getInitialImageSizeKb(initialState?.image));
+			const gateAttempt = this.initialStateGate.startAttempt(initialState);
+			const { roomInfo, initialStateAck } = await this.signaling.openAndJoin({
+				connectTimeout: REALTIME_CONFIG.session.connectionTimeoutMs,
+				initialState
+			});
+			if (this.disposed || this.currentAttempt !== attempt) {
+				this.tearDown();
+				throw new AbortError("Stale connect attempt");
+			}
+			this.queue = null;
+			try {
+				await this.media.connect({
+					url: roomInfo.livekitUrl,
+					token: roomInfo.token
+				});
+				if (!await gateAttempt.waitForReadiness(initialStateAck)) throw new AbortError("Stale connect attempt");
+				await this.media.publishLocalTracks();
+			} catch (error) {
+				this.tearDown();
+				throw error;
+			}
+			if (this.disposed || this.currentAttempt !== attempt) {
+				this.tearDown();
+				throw new AbortError("Stale connect attempt");
+			}
+			this.config.observability?.finishConnectionBreakdown({ success: true });
+			this.setState("connected");
+			this.events.emit("sessionStarted", {
+				sessionId: roomInfo.sessionId,
+				subscribeToken: encodeSubscribeToken(roomInfo.roomName)
+			});
+		} catch (error) {
+			this.config.observability?.finishConnectionBreakdown({
+				success: false,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		}
+	}
+	getInitialState() {
+		if (this.config.initialImageRef !== void 0) return {
+			imageRef: this.config.initialImageRef,
+			prompt: this.config.initialPrompt?.text,
+			enhance: this.config.initialPrompt?.enhance
+		};
+		if (this.config.initialImage !== void 0) return {
+			image: this.config.initialImage,
+			prompt: this.config.initialPrompt?.text,
+			enhance: this.config.initialPrompt?.enhance
+		};
+		if (this.config.initialPrompt) return {
+			prompt: this.config.initialPrompt.text,
+			enhance: this.config.initialPrompt.enhance
+		};
+		if (this.config.localStream) return {
+			image: null,
+			prompt: null
+		};
+	}
+	wireSignalingEvents() {
+		this.signaling.on("queuePosition", (qp) => {
+			this.queue = qp;
+			this.events.emit("queuePosition", qp);
+		});
+		this.signaling.on("generationTick", (e) => this.events.emit("generationTick", e));
+		this.signaling.on("generationEnded", (e) => this.events.emit("generationEnded", e));
+		this.signaling.on("serverError", (err) => this.events.emit("error", err));
+		this.signaling.on("closed", (info) => this.handleConnectionLoss({
+			source: "signaling",
+			...info
+		}));
+	}
+	wireMediaEvents() {
+		this.media.on("remoteStream", (stream) => this.events.emit("remoteStream", stream));
+		this.media.on("firstFrame", () => {
+			if (this.state === "connected") this.setState("generating");
+		});
+		this.media.on("disconnected", (info) => this.handleConnectionLoss({
+			source: "media",
+			reason: info.reason
+		}));
+	}
+	handleConnectionLoss(cause) {
+		if (this.disposed) return;
+		if (this.state !== "connected" && this.state !== "generating") {
+			this.logger.debug("connection loss ignored (not connected)", {
+				state: this.state,
+				...cause
+			});
+			return;
+		}
+		this.logger.warn("realtime connection lost; scheduling reconnect", {
+			state: this.state,
+			...cause
+		});
+		this.scheduleReconnect();
+	}
+	scheduleReconnect() {
+		const attempt = ++this.currentAttempt;
+		this.setState("reconnecting");
+		pRetry(async () => {
+			if (this.disposed || this.currentAttempt !== attempt) throw new AbortError("Reconnect cancelled");
+			this.tearDown();
+			this.createTransport();
+			await this.runOneConnect(attempt);
+		}, this.retryOptionsFor(attempt)).then(() => {
+			if (this.disposed || this.currentAttempt !== attempt) return;
+			this.logger.info("realtime reconnect: succeeded");
+		}).catch((error) => {
+			if (this.disposed || this.currentAttempt !== attempt) return;
+			const message = error instanceof Error ? error.message : String(error);
+			this.logger.error("realtime reconnect: failed permanently", { error: message });
+			this.tearDown();
+			this.setState("disconnected");
+			this.events.emit("error", error instanceof Error ? error : new Error(String(error)));
+		});
+	}
+	createTransport() {
+		this.signaling = new SignalingChannel({
+			url: this.config.url,
+			integration: this.config.integration,
+			logger: this.logger,
+			observability: this.config.observability
+		});
+		this.media = new MediaChannel({
+			observability: this.config.observability,
+			localStream: this.config.localStream,
+			logger: this.logger,
+			videoCodec: this.config.videoCodec
+		});
+		this.wireSignalingEvents();
+		this.wireMediaEvents();
+	}
+	tearDown() {
+		this.signaling.close();
+		this.media.disconnect();
+		this.initialStateGate.reset();
+		this.resetHandshakeState();
+	}
+	resetHandshakeState() {
+		this.queue = null;
+	}
+	setState(state) {
+		if (this.state === state) return;
+		this.logger.debug("realtime state change", {
+			from: this.state,
+			to: state
+		});
+		this.state = state;
+		this.events.emit("connectionChange", state);
+	}
+};
+//#endregion
+export { StreamSession };

package/dist/realtime/subscribe-client.d.ts

@@ -1,7 +1,6 @@
 import { DecartSDKError } from "../utils/errors.js";
-import { ConnectionState } from "./types.js";
 import { DiagnosticEvent } from "./observability/diagnostics.js";
-import { WebRTCStats } from "./observability/webrtc-stats.js";
+import { ConnectionState } from "./types.js";
 
 //#region src/realtime/subscribe-client.d.ts
 
@@ -9,7 +8,6 @@ type SubscribeEvents = {
   connectionChange: ConnectionState;
   error: DecartSDKError;
   diagnostic: DiagnosticEvent;
-  stats: WebRTCStats;
 };
 type RealTimeSubscribeClient = {
   isConnected: () => boolean;
@@ -21,6 +19,7 @@ type RealTimeSubscribeClient = {
 type SubscribeOptions = {
   token: string;
   onRemoteStream: (stream: MediaStream) => void;
+  onConnectionChange?: (state: ConnectionState) => void;
 };
 //#endregion
 export { RealTimeSubscribeClient, SubscribeEvents, SubscribeOptions };

package/dist/realtime/subscribe-client.js

@@ -1,20 +1,124 @@
+import { classifyWebrtcError } from "../utils/errors.js";
+import { createConsoleLogger } from "../utils/logger.js";
+import { createEventBuffer } from "./event-buffer.js";
+import { REALTIME_CONFIG } from "./config-realtime.js";
+import { RealtimeObservability } from "./observability/realtime-observability.js";
+import { ConnectionState, Room, RoomEvent, Track } from "livekit-client";
 //#region src/realtime/subscribe-client.ts
-function encodeSubscribeToken(sessionId, serverIp, serverPort) {
-	return btoa(JSON.stringify({
-		sid: sessionId,
-		ip: serverIp,
-		port: serverPort
-	}));
-}
 function decodeSubscribeToken(token) {
 	try {
 		const payload = JSON.parse(atob(token));
-		if (!payload.sid || !payload.ip || !payload.port) throw new Error("Invalid subscribe token format");
-		return payload;
+		if (!payload.room_name || typeof payload.room_name !== "string") throw new Error("Invalid subscribe token format");
+		return { room_name: payload.room_name };
 	} catch {
 		throw new Error("Invalid subscribe token");
 	}
 }
-
+function mapLiveKitState(state) {
+	switch (state) {
+		case ConnectionState.Connecting: return "connecting";
+		case ConnectionState.Connected: return "connected";
+		case ConnectionState.Reconnecting:
+		case ConnectionState.SignalReconnecting: return "reconnecting";
+		case ConnectionState.Disconnected: return "disconnected";
+		default: return "disconnected";
+	}
+}
+async function fetchWatchStreamCredentials(opts) {
+	if (!/^https?:\/\//i.test(opts.baseUrl)) throw new Error(`watch-stream baseUrl must use http(s); got ${opts.baseUrl}`);
+	const url = `${opts.baseUrl}/watch-stream/${encodeURIComponent(opts.roomName)}`;
+	const res = await fetch(url, {
+		method: "POST",
+		headers: {
+			"x-api-key": opts.apiKey,
+			"content-type": "application/json"
+		}
+	});
+	if (!res.ok) {
+		const body = await res.text().catch(() => "");
+		throw new Error(`watch-stream request failed (${res.status}): ${body || res.statusText}`);
+	}
+	const json = await res.json();
+	if (!json.livekit_url || !json.token || !json.room_name) throw new Error("watch-stream response missing required fields");
+	return {
+		livekit_url: json.livekit_url,
+		token: json.token,
+		room_name: json.room_name
+	};
+}
+const createRealTimeSubscribeClient = (opts) => {
+	const { baseUrl, apiKey, integration } = opts;
+	const logger = opts.logger ?? createConsoleLogger("info");
+	const subscribe = async (options) => {
+		const { room_name: roomName } = decodeSubscribeToken(options.token);
+		const { emitter, emitOrBuffer, flush, stop } = createEventBuffer();
+		let observability;
+		let room;
+		let currentState = "connecting";
+		let remoteStream = null;
+		const setState = (state) => {
+			if (currentState === state) return;
+			currentState = state;
+			options.onConnectionChange?.(state);
+			emitOrBuffer("connectionChange", state);
+		};
+		try {
+			observability = new RealtimeObservability({
+				telemetryEnabled: false,
+				apiKey,
+				integration,
+				logger,
+				onDiagnostic: (event) => emitOrBuffer("diagnostic", event)
+			});
+			setState("connecting");
+			const creds = await fetchWatchStreamCredentials({
+				baseUrl,
+				apiKey,
+				roomName
+			});
+			room = new Room(REALTIME_CONFIG.livekit.roomOptions);
+			const activeRoom = room;
+			activeRoom.on(RoomEvent.TrackSubscribed, (track, _pub, participant) => {
+				if (!participant.identity.startsWith(REALTIME_CONFIG.livekit.inferenceServerIdentityPrefix)) return;
+				if (track.kind !== Track.Kind.Video && track.kind !== Track.Kind.Audio) return;
+				track.attach();
+				const mediaStreamTrack = track.mediaStreamTrack;
+				if (!mediaStreamTrack) return;
+				remoteStream ??= new MediaStream();
+				if (!remoteStream.getTracks().includes(mediaStreamTrack)) remoteStream.addTrack(mediaStreamTrack);
+				options.onRemoteStream(remoteStream);
+			});
+			activeRoom.on(RoomEvent.ConnectionStateChanged, (state) => {
+				setState(mapLiveKitState(state));
+			});
+			activeRoom.on(RoomEvent.Disconnected, () => {
+				setState("disconnected");
+			});
+			await activeRoom.connect(creds.livekit_url, creds.token);
+			observability.setLiveKitRoom(activeRoom);
+			setState("connected");
+			const client = {
+				isConnected: () => activeRoom.state === ConnectionState.Connected,
+				getConnectionState: () => mapLiveKitState(activeRoom.state),
+				disconnect: () => {
+					observability?.stop();
+					stop();
+					activeRoom.disconnect().catch(() => {});
+				},
+				on: emitter.on,
+				off: emitter.off
+			};
+			flush();
+			return client;
+		} catch (error) {
+			observability?.stop();
+			if (room) room.disconnect().catch(() => {});
+			const err = error instanceof Error ? error : new Error(String(error));
+			logger.error("Realtime subscribe error", { error: err.message });
+			throw classifyWebrtcError(err);
+		}
+	};
+	return { subscribe };
+};
 //#endregion
-export { decodeSubscribeToken, encodeSubscribeToken };
+export { createRealTimeSubscribeClient };

package/dist/realtime/types.d.ts

@@ -1,5 +1,29 @@
 //#region src/realtime/types.d.ts
 
+type GenerationEndedMessage = GenerationEnded & {
+  type: "generation_ended";
+};
+type QueuePositionMessage = {
+  type: "queue_position";
+  position: number;
+  queue_size: number;
+};
+type QueuePosition = {
+  position: number;
+  queueSize: number;
+};
 type ConnectionState = "connecting" | "connected" | "generating" | "disconnected" | "reconnecting";
+type GenerationTick = {
+  seconds: number;
+};
+type GenerationEnded = {
+  seconds: number;
+  reason: string;
+};
+type ImageSetOptions = {
+  prompt?: string | null;
+  enhance?: boolean;
+  timeout?: number;
+};
 //#endregion
-export { ConnectionState };
+export { ConnectionState, GenerationEnded, GenerationEndedMessage, GenerationTick, ImageSetOptions, QueuePosition, QueuePositionMessage };

package/dist/shared/model.d.ts

@@ -318,11 +318,17 @@ declare const modelInputSchemas: {
   }, z.core.$strip>;
 };
 type ModelInputSchemas = typeof modelInputSchemas;
+type ModelFps = number | {
+  max?: number;
+  min?: number;
+  ideal?: number;
+  exact?: number;
+};
 type ModelDefinition<T extends Model = Model> = {
   name: T;
   urlPath: string;
   queueUrlPath?: string;
-  fps: number;
+  fps: ModelFps;
   width: number;
   height: number;
   inputSchema: T extends keyof ModelInputSchemas ? ModelInputSchemas[T] : z.ZodTypeAny;
@@ -341,6 +347,7 @@ type CustomModelDefinition = Omit<ModelDefinition, "name" | "inputSchema"> & {
  * Requires `queueUrlPath` to distinguish from realtime definitions of the same model name.
  */
 type ImageModelDefinition = ModelDefinition<ImageModels> & {
+  fps: number;
   queueUrlPath: string;
 };
 /**
@@ -349,6 +356,7 @@ type ImageModelDefinition = ModelDefinition<ImageModels> & {
  * Requires `queueUrlPath` to distinguish from realtime definitions of the same model name.
  */
 type VideoModelDefinition = ModelDefinition<VideoModels> & {
+  fps: number;
   queueUrlPath: string;
 };
 type ModelKind = "realtime" | "video" | "image";
@@ -386,6 +394,7 @@ declare const models: {
    *   - `"lucy-restyle-2"` - Video restyling
    */
   video: <T extends VideoModels>(model: T) => ModelDefinition<T> & {
+    fps: number;
     queueUrlPath: string;
   };
   /**
@@ -395,6 +404,7 @@ declare const models: {
    *   - `"lucy-image-2"` - Image-to-image editing
    */
   image: <T extends ImageModels>(model: T) => ModelDefinition<T> & {
+    fps: number;
     queueUrlPath: string;
   };
 };

package/dist/shared/model.js

@@ -1,6 +1,5 @@
 import { createModelNotFoundError } from "../utils/errors.js";
 import { z } from "zod";
-
 //#region src/shared/model.ts
 const CANONICAL_MODEL_NAMES = [
 	"lucy-2.1",
@@ -195,11 +194,20 @@ const modelInputSchemas = {
 	"lucy-pro-i2i": imageEditSchema,
 	"lucy-restyle-v2v": restyleSchema
 };
+function resolveFpsNumber(fps, fallback = 30) {
+	if (typeof fps === "number") return fps;
+	return fps.ideal ?? fps.max ?? fps.exact ?? fps.min ?? fallback;
+}
 const modelDefinitionSchema = z.object({
 	name: z.string(),
 	urlPath: z.string(),
 	queueUrlPath: z.string().optional(),
-	fps: z.number().min(1),
+	fps: z.union([z.number().min(1), z.object({
+		max: z.number().min(1).optional(),
+		min: z.number().min(1).optional(),
+		ideal: z.number().min(1).optional(),
+		exact: z.number().min(1).optional()
+	})]),
 	width: z.number().min(1),
 	height: z.number().min(1),
 	inputSchema: z.any().optional()
@@ -209,7 +217,10 @@ const _models = {
 		"lucy-2.1": {
 			urlPath: "/v1/stream",
 			name: "lucy-2.1",
-			fps: 20,
+			fps: {
+				ideal: 30,
+				max: 30
+			},
 			width: 1088,
 			height: 624,
 			inputSchema: z.object({})
@@ -217,7 +228,10 @@ const _models = {
 		"lucy-2.1-vton": {
 			urlPath: "/v1/stream",
 			name: "lucy-2.1-vton",
-			fps: 20,
+			fps: {
+				ideal: 30,
+				max: 30
+			},
 			width: 1088,
 			height: 624,
 			inputSchema: z.object({})
@@ -225,7 +239,10 @@ const _models = {
 		"lucy-vton-2": {
 			urlPath: "/v1/stream",
 			name: "lucy-vton-2",
-			fps: 20,
+			fps: {
+				ideal: 30,
+				max: 30
+			},
 			width: 1088,
 			height: 624,
 			inputSchema: z.object({})
@@ -233,7 +250,10 @@ const _models = {
 		"lucy-restyle-2": {
 			urlPath: "/v1/stream",
 			name: "lucy-restyle-2",
-			fps: 22,
+			fps: {
+				ideal: 30,
+				max: 30
+			},
 			width: 1280,
 			height: 704,
 			inputSchema: z.object({})
@@ -241,7 +261,10 @@ const _models = {
 		"lucy-latest": {
 			urlPath: "/v1/stream",
 			name: "lucy-latest",
-			fps: 20,
+			fps: {
+				ideal: 30,
+				max: 30
+			},
 			width: 1088,
 			height: 624,
 			inputSchema: z.object({})
@@ -249,7 +272,10 @@ const _models = {
 		"lucy-vton-latest": {
 			urlPath: "/v1/stream",
 			name: "lucy-vton-latest",
-			fps: 20,
+			fps: {
+				ideal: 30,
+				max: 30
+			},
 			width: 1088,
 			height: 624,
 			inputSchema: z.object({})
@@ -257,7 +283,10 @@ const _models = {
 		"lucy-restyle-latest": {
 			urlPath: "/v1/stream",
 			name: "lucy-restyle-latest",
-			fps: 22,
+			fps: {
+				ideal: 30,
+				max: 30
+			},
 			width: 1280,
 			height: 704,
 			inputSchema: z.object({})
@@ -265,7 +294,10 @@ const _models = {
 		mirage_v2: {
 			urlPath: "/v1/stream",
 			name: "mirage_v2",
-			fps: 22,
+			fps: {
+				ideal: 30,
+				max: 30
+			},
 			width: 1280,
 			height: 704,
 			inputSchema: z.object({})
@@ -273,7 +305,10 @@ const _models = {
 		"lucy-vton": {
 			urlPath: "/v1/stream",
 			name: "lucy-vton",
-			fps: 20,
+			fps: {
+				ideal: 30,
+				max: 30
+			},
 			width: 1088,
 			height: 624,
 			inputSchema: z.object({})
@@ -281,7 +316,10 @@ const _models = {
 		"lucy-2.1-vton-2": {
 			urlPath: "/v1/stream",
 			name: "lucy-2.1-vton-2",
-			fps: 20,
+			fps: {
+				ideal: 30,
+				max: 30
+			},
 			width: 1088,
 			height: 624,
 			inputSchema: z.object({})
@@ -479,6 +517,5 @@ const models = {
 		return modelDefinition;
 	}
 };
-
 //#endregion
-export { isCanonicalModel, isImageModel, isModel, isRealtimeModel, isVideoModel, listModels, modelAliases, modelDefinitionSchema, models, resolveCanonicalModelAlias, resolveModelAlias };
+export { isCanonicalModel, isImageModel, isModel, isRealtimeModel, isVideoModel, listModels, modelAliases, modelDefinitionSchema, models, resolveCanonicalModelAlias, resolveFpsNumber, resolveModelAlias };

package/dist/shared/request.js

@@ -1,6 +1,5 @@
 import { createInvalidInputError } from "../utils/errors.js";
 import { buildUserAgent } from "../utils/user-agent.js";
-
 //#region src/shared/request.ts
 /**
 * Type guard to check if a value is a React Native file object.
@@ -46,6 +45,5 @@ function buildFormData(inputs) {
 	else formData.append(key, String(value));
 	return formData;
 }
-
 //#endregion
-export { buildAuthHeaders, buildFormData, fileInputToBlob };
+export { buildAuthHeaders, buildFormData, fileInputToBlob };

package/dist/shared/types.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-
 //#region src/shared/types.ts
 const modelStateSchema = z.object({
 	prompt: z.object({
@@ -12,6 +11,5 @@ const modelStateSchema = z.object({
 		z.string()
 	]).optional()
 });
-
 //#endregion
-export { modelStateSchema };
+export { modelStateSchema };

package/dist/tokens/client.js

@@ -1,6 +1,5 @@
 import { createSDKError } from "../utils/errors.js";
 import { buildAuthHeaders } from "../shared/request.js";
-
 //#region src/tokens/client.ts
 const createTokensClient = (opts) => {
 	const { baseUrl, apiKey, integration } = opts;
@@ -25,6 +24,5 @@ const createTokensClient = (opts) => {
 	};
 	return { create };
 };
-
 //#endregion
-export { createTokensClient };
+export { createTokensClient };