@decartai/sdk 0.0.26 → 0.0.28

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { ImageModelDefinition, ImageModels, Model, ModelDefinition, RealTimeModels, VideoModelDefinition, VideoModels, models } from "./shared/model.js";
+import { ImageModelDefinition, ImageModels, Model, ModelDefinition, RealTimeModels, VideoModelDefinition, VideoModels, isImageModel, isRealtimeModel, isVideoModel, models } from "./shared/model.js";
 import { FileInput, ProcessOptions } from "./process/types.js";
 import { ProcessClient } from "./process/client.js";
 import { JobStatus, JobStatusResponse, JobSubmitResponse, QueueJobResult, QueueSubmitAndPollOptions, QueueSubmitOptions } from "./queue/types.js";
 import { QueueClient } from "./queue/client.js";
 import { DecartSDKError, ERROR_CODES } from "./utils/errors.js";
-import { RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState } from "./realtime/client.js";
+import { AvatarOptions, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState } from "./realtime/client.js";
 import { ModelState } from "./shared/types.js";
 import { CreateTokenResponse, TokensClient } from "./tokens/client.js";
 import { z } from "zod";
@@ -35,7 +35,7 @@ type DecartClientOptions = z.infer<typeof decartClientOptionsSchema>;
  */
 declare const createDecartClient: (options?: DecartClientOptions) => {
   realtime: {
-    connect: (stream: MediaStream, options: RealTimeClientConnectOptions) => Promise<RealTimeClient>;
+    connect: (stream: MediaStream | null, options: RealTimeClientConnectOptions) => Promise<RealTimeClient>;
   };
   /**
    * Client for synchronous image generation.
@@ -109,4 +109,4 @@ declare const createDecartClient: (options?: DecartClientOptions) => {
   tokens: TokensClient;
 };
 //#endregion
-export { type CreateTokenResponse, DecartClientOptions, type DecartSDKError, ERROR_CODES, type FileInput, type ImageModelDefinition, type ImageModels, type JobStatus, type JobStatusResponse, type JobSubmitResponse, type Model, type ModelDefinition, type ModelState, type ProcessClient, type ProcessOptions, type QueueClient, type QueueJobResult, type QueueSubmitAndPollOptions, type QueueSubmitOptions, type RealTimeClient, type RealTimeClientConnectOptions, type RealTimeClientInitialState, type RealTimeModels, type TokensClient, type VideoModelDefinition, type VideoModels, createDecartClient, models };
+export { type AvatarOptions, type CreateTokenResponse, DecartClientOptions, type DecartSDKError, ERROR_CODES, type FileInput, type ImageModelDefinition, type ImageModels, type JobStatus, type JobStatusResponse, type JobSubmitResponse, type Model, type ModelDefinition, type ModelState, type ProcessClient, type ProcessOptions, type QueueClient, type QueueJobResult, type QueueSubmitAndPollOptions, type QueueSubmitOptions, type RealTimeClient, type RealTimeClientConnectOptions, type RealTimeClientInitialState, type RealTimeModels, type TokensClient, type VideoModelDefinition, type VideoModels, createDecartClient, isImageModel, isRealtimeModel, isVideoModel, models };

package/dist/index.js

@@ -1,7 +1,7 @@
 import { ERROR_CODES, createInvalidApiKeyError, createInvalidBaseUrlError } from "./utils/errors.js";
 import { createProcessClient } from "./process/client.js";
 import { createQueueClient } from "./queue/client.js";
-import { models } from "./shared/model.js";
+import { isImageModel, isRealtimeModel, isVideoModel, models } from "./shared/model.js";
 import { createRealTimeClient } from "./realtime/client.js";
 import { createTokensClient } from "./tokens/client.js";
 import { readEnv } from "./utils/env.js";
@@ -67,4 +67,4 @@ const createDecartClient = (options = {}) => {
 };
 
 //#endregion
-export { ERROR_CODES, createDecartClient, models };
+export { ERROR_CODES, createDecartClient, isImageModel, isRealtimeModel, isVideoModel, models };

package/dist/realtime/audio-stream-manager.js

@@ -0,0 +1,90 @@
+//#region src/realtime/audio-stream-manager.ts
+/**
+* Manages an audio stream for avatar-live mode.
+* Creates a continuous audio stream that outputs silence by default,
+* and allows playing audio files through the stream.
+*/
+var AudioStreamManager = class {
+	audioContext;
+	destination;
+	silenceOscillator;
+	silenceGain;
+	currentSource = null;
+	_isPlaying = false;
+	constructor() {
+		this.audioContext = new AudioContext();
+		this.destination = this.audioContext.createMediaStreamDestination();
+		this.silenceOscillator = this.audioContext.createOscillator();
+		this.silenceGain = this.audioContext.createGain();
+		this.silenceGain.gain.value = 0;
+		this.silenceOscillator.connect(this.silenceGain);
+		this.silenceGain.connect(this.destination);
+		this.silenceOscillator.start();
+	}
+	/**
+	* Get the MediaStream to pass to WebRTC.
+	* This stream outputs silence when no audio is playing.
+	*/
+	getStream() {
+		return this.destination.stream;
+	}
+	/**
+	* Check if audio is currently playing.
+	*/
+	isPlaying() {
+		return this._isPlaying;
+	}
+	/**
+	* Play audio through the stream.
+	* When the audio ends, the stream automatically reverts to silence.
+	* @param audio - Audio data as Blob, File, or ArrayBuffer
+	* @returns Promise that resolves when audio finishes playing
+	*/
+	async playAudio(audio) {
+		if (this.audioContext.state === "suspended") await this.audioContext.resume();
+		if (this._isPlaying) this.stopAudio();
+		let arrayBuffer;
+		if (audio instanceof ArrayBuffer) arrayBuffer = audio;
+		else arrayBuffer = await audio.arrayBuffer();
+		const audioBuffer = await this.audioContext.decodeAudioData(arrayBuffer);
+		const source = this.audioContext.createBufferSource();
+		source.buffer = audioBuffer;
+		source.connect(this.destination);
+		this.currentSource = source;
+		this._isPlaying = true;
+		return new Promise((resolve) => {
+			source.onended = () => {
+				this._isPlaying = false;
+				this.currentSource = null;
+				resolve();
+			};
+			source.start();
+		});
+	}
+	/**
+	* Stop currently playing audio immediately.
+	* The stream will revert to silence.
+	*/
+	stopAudio() {
+		if (this.currentSource) {
+			try {
+				this.currentSource.stop();
+			} catch {}
+			this.currentSource = null;
+		}
+		this._isPlaying = false;
+	}
+	/**
+	* Clean up resources.
+	*/
+	cleanup() {
+		this.stopAudio();
+		try {
+			this.silenceOscillator.stop();
+		} catch {}
+		this.audioContext.close();
+	}
+};
+
+//#endregion
+export { AudioStreamManager };

package/dist/realtime/client.d.ts

@@ -11,9 +11,13 @@ declare const realTimeClientInitialStateSchema: z.ZodObject<{
 }, z.core.$strip>;
 type OnRemoteStreamFn = (stream: MediaStream) => void;
 type RealTimeClientInitialState = z.infer<typeof realTimeClientInitialStateSchema>;
+declare const avatarOptionsSchema: z.ZodObject<{
+  avatarImage: z.ZodUnion<readonly [z.ZodCustom<Blob, Blob>, z.ZodCustom<File, File>, z.ZodString]>;
+}, z.core.$strip>;
+type AvatarOptions = z.infer<typeof avatarOptionsSchema>;
 declare const realTimeClientConnectOptionsSchema: z.ZodObject<{
   model: z.ZodObject<{
-    name: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"mirage">, z.ZodLiteral<"mirage_v2">, z.ZodLiteral<"lucy_v2v_720p_rt">]>, z.ZodUnion<readonly [z.ZodLiteral<"lucy-dev-i2v">, z.ZodLiteral<"lucy-fast-v2v">, z.ZodLiteral<"lucy-pro-t2v">, z.ZodLiteral<"lucy-pro-i2v">, z.ZodLiteral<"lucy-pro-v2v">, z.ZodLiteral<"lucy-pro-flf2v">, z.ZodLiteral<"lucy-motion">, z.ZodLiteral<"lucy-restyle-v2v">]>, z.ZodUnion<readonly [z.ZodLiteral<"lucy-pro-t2i">, z.ZodLiteral<"lucy-pro-i2i">]>]>;
+    name: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"mirage">, z.ZodLiteral<"mirage_v2">, z.ZodLiteral<"lucy_v2v_720p_rt">, z.ZodLiteral<"avatar-live">]>, z.ZodUnion<readonly [z.ZodLiteral<"lucy-dev-i2v">, z.ZodLiteral<"lucy-fast-v2v">, z.ZodLiteral<"lucy-pro-t2v">, z.ZodLiteral<"lucy-pro-i2v">, z.ZodLiteral<"lucy-pro-v2v">, z.ZodLiteral<"lucy-pro-flf2v">, z.ZodLiteral<"lucy-motion">, z.ZodLiteral<"lucy-restyle-v2v">]>, z.ZodUnion<readonly [z.ZodLiteral<"lucy-pro-t2i">, z.ZodLiteral<"lucy-pro-i2i">]>]>;
     urlPath: z.ZodString;
     queueUrlPath: z.ZodOptional<z.ZodString>;
     fps: z.ZodNumber;
@@ -29,6 +33,9 @@ declare const realTimeClientConnectOptionsSchema: z.ZodObject<{
     }, z.core.$strip>>;
   }, z.core.$strip>>;
   customizeOffer: z.ZodOptional<z.ZodCustom<z.core.$InferInnerFunctionTypeAsync<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>, z.core.$InferInnerFunctionTypeAsync<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>>;
+  avatar: z.ZodOptional<z.ZodObject<{
+    avatarImage: z.ZodUnion<readonly [z.ZodCustom<Blob, Blob>, z.ZodCustom<File, File>, z.ZodString]>;
+  }, z.core.$strip>>;
 }, z.core.$strip>;
 type RealTimeClientConnectOptions = z.infer<typeof realTimeClientConnectOptionsSchema>;
 type Events = {
@@ -47,6 +54,8 @@ type RealTimeClient = {
   on: <K extends keyof Events>(event: K, listener: (data: Events[K]) => void) => void;
   off: <K extends keyof Events>(event: K, listener: (data: Events[K]) => void) => void;
   sessionId: string;
+  setImage: (image: Blob | File | string) => Promise<void>;
+  playAudio?: (audio: Blob | File | ArrayBuffer) => Promise<void>;
 };
 //#endregion
-export { RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState };
+export { AvatarOptions, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState };

package/dist/realtime/client.js

@@ -1,6 +1,7 @@
 import { createWebrtcError } from "../utils/errors.js";
 import { modelDefinitionSchema } from "../shared/model.js";
 import { modelStateSchema } from "../shared/types.js";
+import { AudioStreamManager } from "./audio-stream-manager.js";
 import { realtimeMethods } from "./methods.js";
 import { WebRTCManager } from "./webrtc-manager.js";
 import { z } from "zod";
@@ -8,13 +9,30 @@ import mitt from "mitt";
 import { v4 } from "uuid";
 
 //#region src/realtime/client.ts
+async function blobToBase64(blob) {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onloadend = () => {
+			const base64 = reader.result.split(",")[1];
+			resolve(base64);
+		};
+		reader.onerror = reject;
+		reader.readAsDataURL(blob);
+	});
+}
 const realTimeClientInitialStateSchema = modelStateSchema;
 const createAsyncFunctionSchema = (schema) => z.custom((fn) => schema.implementAsync(fn));
+const avatarOptionsSchema = z.object({ avatarImage: z.union([
+	z.instanceof(Blob),
+	z.instanceof(File),
+	z.string()
+]) });
 const realTimeClientConnectOptionsSchema = z.object({
 	model: modelDefinitionSchema,
 	onRemoteStream: z.custom((val) => typeof val === "function", { message: "onRemoteStream must be a function" }),
 	initialState: realTimeClientInitialStateSchema.optional(),
-	customizeOffer: createAsyncFunctionSchema(z.function()).optional()
+	customizeOffer: createAsyncFunctionSchema(z.function()).optional(),
+	avatar: avatarOptionsSchema.optional()
 });
 const createRealTimeClient = (opts) => {
 	const { baseUrl, apiKey, integration } = opts;
@@ -23,7 +41,21 @@ const createRealTimeClient = (opts) => {
 		const parsedOptions = realTimeClientConnectOptionsSchema.safeParse(options);
 		if (!parsedOptions.success) throw parsedOptions.error;
 		const sessionId = v4();
-		const { onRemoteStream, initialState } = parsedOptions.data;
+		const isAvatarLive = options.model.name === "avatar-live";
+		const { onRemoteStream, initialState, avatar } = parsedOptions.data;
+		let audioStreamManager;
+		let inputStream;
+		if (isAvatarLive && !stream) {
+			audioStreamManager = new AudioStreamManager();
+			inputStream = audioStreamManager.getStream();
+		} else inputStream = stream ?? new MediaStream();
+		let avatarImageBase64;
+		if (isAvatarLive && avatar?.avatarImage) {
+			let imageBlob;
+			if (typeof avatar.avatarImage === "string") imageBlob = await (await fetch(avatar.avatarImage)).blob();
+			else imageBlob = avatar.avatarImage;
+			avatarImageBase64 = await blobToBase64(imageBlob);
+		}
 		const webrtcManager = new WebRTCManager({
 			webrtcUrl: `${`${baseUrl}${options.model.urlPath}`}?api_key=${apiKey}&model=${options.model.name}`,
 			apiKey,
@@ -41,9 +73,11 @@ const createRealTimeClient = (opts) => {
 			},
 			customizeOffer: options.customizeOffer,
 			vp8MinBitrate: 300,
-			vp8StartBitrate: 600
+			vp8StartBitrate: 600,
+			isAvatarLive,
+			avatarImageBase64
 		});
-		await webrtcManager.connect(stream);
+		await webrtcManager.connect(inputStream);
 		const methods = realtimeMethods(webrtcManager);
 		if (options.initialState) {
 			if (options.initialState.prompt) {
@@ -51,15 +85,36 @@ const createRealTimeClient = (opts) => {
 				methods.setPrompt(text, { enhance });
 			}
 		}
-		return {
+		const client = {
 			setPrompt: methods.setPrompt,
 			isConnected: () => webrtcManager.isConnected(),
 			getConnectionState: () => webrtcManager.getConnectionState(),
-			disconnect: () => webrtcManager.cleanup(),
+			disconnect: () => {
+				webrtcManager.cleanup();
+				audioStreamManager?.cleanup();
+			},
 			on: eventEmitter.on,
 			off: eventEmitter.off,
-			sessionId
+			sessionId,
+			setImage: async (image) => {
+				let imageBase64;
+				if (typeof image === "string") {
+					let url = null;
+					try {
+						url = new URL(image);
+					} catch {}
+					if (url?.protocol === "data:") imageBase64 = image.split(",")[1];
+					else if (url?.protocol === "http:" || url?.protocol === "https:") imageBase64 = await blobToBase64(await (await fetch(image)).blob());
+					else imageBase64 = image;
+				} else imageBase64 = await blobToBase64(image);
+				return webrtcManager.setImage(imageBase64);
+			}
 		};
+		if (isAvatarLive && audioStreamManager) {
+			const manager = audioStreamManager;
+			client.playAudio = (audio) => manager.playAudio(audio);
+		}
+		return client;
 	};
 	return { connect };
 };

package/dist/realtime/webrtc-connection.js

@@ -3,6 +3,7 @@ import mitt from "mitt";
 
 //#region src/realtime/webrtc-connection.ts
 const ICE_SERVERS = [{ urls: "stun:stun.l.google.com:19302" }];
+const AVATAR_SETUP_TIMEOUT_MS = 15e3;
 var WebRTCConnection = class {
 	pc = null;
 	ws = null;
@@ -38,6 +39,7 @@ var WebRTCConnection = class {
 			};
 			this.ws.onclose = () => this.setState("disconnected");
 		});
+		if (this.callbacks.avatarImageBase64) await this.sendAvatarImage(this.callbacks.avatarImageBase64);
 		await this.setupNewPeerConnection();
 		return new Promise((resolve, reject) => {
 			this.connectionReject = reject;
@@ -55,18 +57,22 @@ var WebRTCConnection = class {
 		});
 	}
 	async handleSignalingMessage(msg) {
-		if (!this.pc) return;
 		try {
-			switch (msg.type) {
-				case "error": {
-					const error = new Error(msg.error);
-					this.callbacks.onError?.(error);
-					if (this.connectionReject) {
-						this.connectionReject(error);
-						this.connectionReject = null;
-					}
-					break;
+			if (msg.type === "error") {
+				const error = new Error(msg.error);
+				this.callbacks.onError?.(error);
+				if (this.connectionReject) {
+					this.connectionReject(error);
+					this.connectionReject = null;
 				}
+				return;
+			}
+			if (msg.type === "image_set") {
+				this.websocketMessagesEmitter.emit("imageSet", msg);
+				return;
+			}
+			if (!this.pc) return;
+			switch (msg.type) {
 				case "ready": {
 					await this.applyCodecPreference("video/VP8");
 					const offer = await this.pc.createOffer();
@@ -118,10 +124,35 @@ var WebRTCConnection = class {
 	send(message) {
 		if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify(message));
 	}
+	async sendAvatarImage(imageBase64) {
+		return this.setImageBase64(imageBase64);
+	}
+	/**
+	* Send an image to the server (e.g., as a reference for inference).
+	* Can be called after connection is established.
+	*/
+	async setImageBase64(imageBase64) {
+		return new Promise((resolve, reject) => {
+			const timeoutId = setTimeout(() => {
+				this.websocketMessagesEmitter.off("imageSet", listener);
+				reject(/* @__PURE__ */ new Error("Image send timed out"));
+			}, AVATAR_SETUP_TIMEOUT_MS);
+			const listener = (msg) => {
+				clearTimeout(timeoutId);
+				this.websocketMessagesEmitter.off("imageSet", listener);
+				if (msg.status === "success") resolve();
+				else reject(/* @__PURE__ */ new Error(`Failed to send image: ${msg.status}`));
+			};
+			this.websocketMessagesEmitter.on("imageSet", listener);
+			this.send({
+				type: "set_image",
+				image_data: imageBase64
+			});
+		});
+	}
 	setState(state) {
 		if (this.state !== state) {
 			this.state = state;
-			console.log(`[WebRTC] State: ${state}`);
 			this.callbacks.onStateChange?.(state);
 		}
 	}
@@ -140,6 +171,7 @@ var WebRTCConnection = class {
 			username: turnConfig.username
 		});
 		this.pc = new RTCPeerConnection({ iceServers });
+		if (this.callbacks.isAvatarLive) this.pc.addTransceiver("video", { direction: "recvonly" });
 		this.localStream.getTracks().forEach((track) => {
 			if (this.pc && this.localStream) this.pc.addTrack(track, this.localStream);
 		});
@@ -173,7 +205,7 @@ var WebRTCConnection = class {
 	}
 	async applyCodecPreference(preferredCodecName) {
 		if (!this.pc) return;
-		const videoTransceiver = this.pc.getTransceivers().find((r) => r.sender.track?.kind === "video");
+		const videoTransceiver = this.pc.getTransceivers().find((r) => r.sender.track?.kind === "video" || r.receiver.track?.kind === "video");
 		if (!videoTransceiver) {
 			console.error("Could not find video transceiver. Ensure track is added to peer connection.");
 			return;

package/dist/realtime/webrtc-manager.js

@@ -21,7 +21,9 @@ var WebRTCManager = class {
 			onError: config.onError,
 			customizeOffer: config.customizeOffer,
 			vp8MinBitrate: config.vp8MinBitrate,
-			vp8StartBitrate: config.vp8StartBitrate
+			vp8StartBitrate: config.vp8StartBitrate,
+			isAvatarLive: config.isAvatarLive,
+			avatarImageBase64: config.avatarImageBase64
 		});
 	}
 	async connect(localStream) {
@@ -58,6 +60,9 @@ var WebRTCManager = class {
 	getWebsocketMessageEmitter() {
 		return this.connection.websocketMessagesEmitter;
 	}
+	setImage(imageBase64) {
+		return this.connection.setImageBase64(imageBase64);
+	}
 };
 
 //#endregion

package/dist/shared/model.d.ts

@@ -1,14 +1,17 @@
 import { z } from "zod";
 
 //#region src/shared/model.d.ts
-declare const realtimeModels: z.ZodUnion<readonly [z.ZodLiteral<"mirage">, z.ZodLiteral<"mirage_v2">, z.ZodLiteral<"lucy_v2v_720p_rt">]>;
+declare const realtimeModels: z.ZodUnion<readonly [z.ZodLiteral<"mirage">, z.ZodLiteral<"mirage_v2">, z.ZodLiteral<"lucy_v2v_720p_rt">, z.ZodLiteral<"avatar-live">]>;
 declare const videoModels: z.ZodUnion<readonly [z.ZodLiteral<"lucy-dev-i2v">, z.ZodLiteral<"lucy-fast-v2v">, z.ZodLiteral<"lucy-pro-t2v">, z.ZodLiteral<"lucy-pro-i2v">, z.ZodLiteral<"lucy-pro-v2v">, z.ZodLiteral<"lucy-pro-flf2v">, z.ZodLiteral<"lucy-motion">, z.ZodLiteral<"lucy-restyle-v2v">]>;
 declare const imageModels: z.ZodUnion<readonly [z.ZodLiteral<"lucy-pro-t2i">, z.ZodLiteral<"lucy-pro-i2i">]>;
-declare const modelSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"mirage">, z.ZodLiteral<"mirage_v2">, z.ZodLiteral<"lucy_v2v_720p_rt">]>, z.ZodUnion<readonly [z.ZodLiteral<"lucy-dev-i2v">, z.ZodLiteral<"lucy-fast-v2v">, z.ZodLiteral<"lucy-pro-t2v">, z.ZodLiteral<"lucy-pro-i2v">, z.ZodLiteral<"lucy-pro-v2v">, z.ZodLiteral<"lucy-pro-flf2v">, z.ZodLiteral<"lucy-motion">, z.ZodLiteral<"lucy-restyle-v2v">]>, z.ZodUnion<readonly [z.ZodLiteral<"lucy-pro-t2i">, z.ZodLiteral<"lucy-pro-i2i">]>]>;
+declare const modelSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"mirage">, z.ZodLiteral<"mirage_v2">, z.ZodLiteral<"lucy_v2v_720p_rt">, z.ZodLiteral<"avatar-live">]>, z.ZodUnion<readonly [z.ZodLiteral<"lucy-dev-i2v">, z.ZodLiteral<"lucy-fast-v2v">, z.ZodLiteral<"lucy-pro-t2v">, z.ZodLiteral<"lucy-pro-i2v">, z.ZodLiteral<"lucy-pro-v2v">, z.ZodLiteral<"lucy-pro-flf2v">, z.ZodLiteral<"lucy-motion">, z.ZodLiteral<"lucy-restyle-v2v">]>, z.ZodUnion<readonly [z.ZodLiteral<"lucy-pro-t2i">, z.ZodLiteral<"lucy-pro-i2i">]>]>;
 type Model = z.infer<typeof modelSchema>;
 type RealTimeModels = z.infer<typeof realtimeModels>;
 type VideoModels = z.infer<typeof videoModels>;
 type ImageModels = z.infer<typeof imageModels>;
+declare function isRealtimeModel(model: string): model is RealTimeModels;
+declare function isVideoModel(model: string): model is VideoModels;
+declare function isImageModel(model: string): model is ImageModels;
 declare const modelInputSchemas: {
   readonly "lucy-pro-t2v": z.ZodObject<{
     prompt: z.ZodString;
@@ -141,4 +144,4 @@ declare const models: {
   image: <T extends ImageModels>(model: T) => ModelDefinition<T>;
 };
 //#endregion
-export { ImageModelDefinition, ImageModels, Model, ModelDefinition, ModelInputSchemas, RealTimeModels, VideoModelDefinition, VideoModels, models };
+export { ImageModelDefinition, ImageModels, Model, ModelDefinition, ModelInputSchemas, RealTimeModels, VideoModelDefinition, VideoModels, isImageModel, isRealtimeModel, isVideoModel, models };

package/dist/shared/model.js

@@ -5,7 +5,8 @@ import { z } from "zod";
 const realtimeModels = z.union([
 	z.literal("mirage"),
 	z.literal("mirage_v2"),
-	z.literal("lucy_v2v_720p_rt")
+	z.literal("lucy_v2v_720p_rt"),
+	z.literal("avatar-live")
 ]);
 const videoModels = z.union([
 	z.literal("lucy-dev-i2v"),
@@ -23,6 +24,15 @@ const modelSchema = z.union([
 	videoModels,
 	imageModels
 ]);
+function isRealtimeModel(model) {
+	return realtimeModels.safeParse(model).success;
+}
+function isVideoModel(model) {
+	return videoModels.safeParse(model).success;
+}
+function isImageModel(model) {
+	return imageModels.safeParse(model).success;
+}
 const fileInputSchema = z.union([
 	z.instanceof(File),
 	z.instanceof(Blob),
@@ -155,6 +165,14 @@ const _models = {
 			width: 1280,
 			height: 704,
 			inputSchema: z.object({})
+		},
+		"avatar-live": {
+			urlPath: "/v1/avatar-live/stream",
+			name: "avatar-live",
+			fps: 25,
+			width: 1280,
+			height: 720,
+			inputSchema: z.object({})
 		}
 	},
 	image: {
@@ -271,4 +289,4 @@ const models = {
 };
 
 //#endregion
-export { modelDefinitionSchema, models };
+export { isImageModel, isRealtimeModel, isVideoModel, modelDefinitionSchema, models };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decartai/sdk",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "Decart's JavaScript SDK",
   "type": "module",
   "license": "MIT",