@decartai/sdk 0.0.27 → 0.0.29

package/dist/index.d.ts

@@ -4,7 +4,7 @@ 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, isImageModel, isRealtimeModel, isVideoModel, 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/process/types.d.ts

@@ -49,6 +49,28 @@ interface VideoModelInputs {
    */
   data?: FileInput;
 }
+/**
+ * Model-specific input documentation for lucy-restyle-v2v.
+ * Allows either prompt or reference_image (mutually exclusive).
+ */
+interface VideoRestyleInputs {
+  /**
+   * Text description to use for the video editing.
+   * Mutually exclusive with reference_image.
+   */
+  prompt?: string;
+  /**
+   * Reference image to transform into a prompt.
+   * Mutually exclusive with prompt.
+   * Can be a File, Blob, ReadableStream, URL, or string URL.
+   */
+  reference_image?: FileInput;
+  /**
+   * Video file to process.
+   * Can be a File, Blob, ReadableStream, URL, or string URL.
+   */
+  data: FileInput;
+}
 /**
  * Default inputs for models that only require a prompt.
  */
@@ -63,7 +85,7 @@ interface PromptInput {
  * This allows different models to have field-specific documentation while maintaining type safety.
  * Specific models are checked first, then falls back to category-based selection.
  */
-type ModelSpecificInputs<T extends ModelDefinition> = T["name"] extends "lucy-pro-i2i" ? ImageEditingInputs : T["name"] extends ImageModels ? ImageGenerationInputs : T["name"] extends VideoModels ? VideoModelInputs : PromptInput;
+type ModelSpecificInputs<T extends ModelDefinition> = T["name"] extends "lucy-pro-i2i" ? ImageEditingInputs : T["name"] extends "lucy-restyle-v2v" ? VideoRestyleInputs : T["name"] extends ImageModels ? ImageGenerationInputs : T["name"] extends VideoModels ? VideoModelInputs : PromptInput;
 interface ProcessInputs {
   /**
    * Random seed for reproducible results.

package/dist/queue/client.js

@@ -11,7 +11,7 @@ const createQueueClient = (opts) => {
 		const parsedInputs = model.inputSchema.safeParse(inputs);
 		if (!parsedInputs.success) throw createInvalidInputError(`Invalid inputs for ${model.name}: ${parsedInputs.error.message}`);
 		const processedInputs = {};
-		for (const [key, value] of Object.entries(parsedInputs.data)) if (key === "data" || key === "start" || key === "end") processedInputs[key] = await fileInputToBlob(value);
+		for (const [key, value] of Object.entries(parsedInputs.data)) if (key === "data" || key === "start" || key === "end" || key === "reference_image") processedInputs[key] = await fileInputToBlob(value);
 		else processedInputs[key] = value;
 		return submitJob({
 			baseUrl,

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,10 +1,10 @@
 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>;
@@ -92,11 +92,12 @@ declare const modelInputSchemas: {
     resolution: z.ZodOptional<z.ZodDefault<z.ZodLiteral<"720p">>>;
   }, z.core.$strip>;
   readonly "lucy-restyle-v2v": z.ZodObject<{
-    prompt: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+    reference_image: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<File, File>, z.ZodCustom<Blob, Blob>, z.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>, z.ZodCustom<URL, URL>, z.ZodURL]>>;
     data: z.ZodUnion<readonly [z.ZodCustom<File, File>, z.ZodCustom<Blob, Blob>, z.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>, z.ZodCustom<URL, URL>, z.ZodURL]>;
     seed: z.ZodOptional<z.ZodNumber>;
     resolution: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"720p">>>;
-    enhance_prompt: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    enhance_prompt: z.ZodOptional<z.ZodBoolean>;
   }, z.core.$strip>;
 };
 type ModelInputSchemas = typeof modelInputSchemas;

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"),
@@ -123,12 +124,13 @@ const modelInputSchemas = {
 		resolution: motionResolutionSchema
 	}),
 	"lucy-restyle-v2v": z.object({
-		prompt: z.string().min(1).max(1e3).describe("Text prompt for the video editing"),
+		prompt: z.string().min(1).max(1e3).optional().describe("Text prompt for the video editing"),
+		reference_image: fileInputSchema.optional().describe("Reference image to transform into a prompt (File, Blob, ReadableStream, URL, or string URL)"),
 		data: fileInputSchema.describe("Video file to process (File, Blob, ReadableStream, URL, or string URL)"),
 		seed: z.number().optional().describe("Seed for the video generation"),
 		resolution: proV2vResolutionSchema,
-		enhance_prompt: z.boolean().default(true).optional().describe("Whether to enhance the prompt")
-	})
+		enhance_prompt: z.boolean().optional().describe("Whether to enhance the prompt (only valid with text prompt, defaults to true on backend)")
+	}).refine((data) => data.prompt !== void 0 !== (data.reference_image !== void 0), { message: "Must provide either 'prompt' or 'reference_image', but not both" }).refine((data) => !(data.reference_image !== void 0 && data.enhance_prompt !== void 0), { message: "'enhance_prompt' is only valid when using 'prompt', not 'reference_image'" })
 };
 const modelDefinitionSchema = z.object({
 	name: modelSchema,
@@ -164,6 +166,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: {

package/package.json

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