@decartai/sdk 0.0.1

package/dist/realtime/client.js

@@ -0,0 +1,62 @@
+import { createWebrtcError } from "../utils/errors.js";
+import { modelDefinitionSchema } from "../shared/model.js";
+import { modelStateSchema } from "../shared/types.js";
+import { realtimeMethods } from "./methods.js";
+import { WebRTCManager } from "./webrtc-manager.js";
+import { z } from "zod";
+import mitt from "mitt";
+import { v4 } from "uuid";
+
+//#region src/realtime/client.ts
+const realTimeClientInitialStateSchema = modelStateSchema;
+const createAsyncFunctionSchema = (schema) => z.custom((fn) => schema.implementAsync(fn));
+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()
+});
+const createRealTimeClient = (opts) => {
+	const { baseUrl, apiKey } = opts;
+	const connect = async (stream, options) => {
+		const eventEmitter = mitt();
+		const parsedOptions = realTimeClientConnectOptionsSchema.safeParse(options);
+		if (!parsedOptions.success) throw parsedOptions.error;
+		const sessionId = v4();
+		const { onRemoteStream, initialState } = parsedOptions.data;
+		const url = `${baseUrl}${options.model.urlPath}`;
+		const webrtcManager = new WebRTCManager({
+			webrtcUrl: `${url}?api_key=${apiKey}&model=${options.model.name}`,
+			apiKey,
+			sessionId,
+			fps: options.model.fps,
+			initialState,
+			onRemoteStream,
+			onConnectionStateChange: (state) => {
+				eventEmitter.emit("connectionChange", state);
+			},
+			onError: (error) => {
+				console.error("WebRTC error:", error);
+				eventEmitter.emit("error", createWebrtcError(error));
+			},
+			customizeOffer: options.customizeOffer
+		});
+		await webrtcManager.connect(stream);
+		const methods = realtimeMethods(webrtcManager);
+		return {
+			enrichPrompt: methods.enrichPrompt,
+			setPrompt: methods.setPrompt,
+			setMirror: methods.setMirror,
+			isConnected: () => webrtcManager.isConnected(),
+			getConnectionState: () => webrtcManager.getConnectionState(),
+			disconnect: () => webrtcManager.cleanup(),
+			on: eventEmitter.on,
+			off: eventEmitter.off,
+			sessionId
+		};
+	};
+	return { connect };
+};
+
+//#endregion
+export { createRealTimeClient };

package/dist/realtime/methods.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+
+//#region src/realtime/methods.ts
+const realtimeMethods = (webrtcManager) => {
+	const enrichPrompt = (_prompt) => {
+		throw new Error("Not implemented");
+	};
+	const setPrompt = (prompt, { enrich } = {}) => {
+		const parsedInput = z.object({
+			prompt: z.string().min(1),
+			enrich: z.boolean().optional().default(true)
+		}).safeParse({
+			prompt,
+			enrich
+		});
+		if (!parsedInput.success) throw parsedInput.error;
+		webrtcManager.sendMessage({
+			type: "prompt",
+			prompt: parsedInput.data.prompt
+		});
+	};
+	const setMirror = (enabled) => {
+		const parsedInput = z.object({ enabled: z.boolean() }).safeParse({ enabled });
+		if (!parsedInput.success) throw parsedInput.error;
+		webrtcManager.sendMessage({
+			type: "switch_camera",
+			rotateY: parsedInput.data.enabled ? 2 : 0
+		});
+	};
+	return {
+		enrichPrompt,
+		setPrompt,
+		setMirror
+	};
+};
+
+//#endregion
+export { realtimeMethods };

package/dist/realtime/webrtc-connection.js

@@ -0,0 +1,144 @@
+//#region src/realtime/webrtc-connection.ts
+const ICE_SERVERS = [{ urls: "stun:stun.l.google.com:19302" }];
+var WebRTCConnection = class {
+	pc = null;
+	ws = null;
+	state = "disconnected";
+	constructor(callbacks = {}) {
+		this.callbacks = callbacks;
+	}
+	async connect(url, localStream, timeout = 15e3) {
+		const deadline = Date.now() + timeout;
+		await new Promise((resolve, reject) => {
+			const timer = setTimeout(() => reject(/* @__PURE__ */ new Error("WebSocket timeout")), timeout);
+			this.ws = new WebSocket(url);
+			this.ws.onopen = () => {
+				clearTimeout(timer);
+				resolve();
+			};
+			this.ws.onmessage = (e) => {
+				try {
+					this.handleSignalingMessage(JSON.parse(e.data));
+				} catch (err) {
+					console.error("[WebRTC] Parse error:", err);
+				}
+			};
+			this.ws.onerror = () => {
+				clearTimeout(timer);
+			};
+			this.ws.onclose = () => this.setState("disconnected");
+		});
+		this.pc?.close();
+		this.pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
+		localStream.getTracks().forEach((track) => this.pc.addTrack(track, localStream));
+		this.pc.ontrack = (e) => {
+			if (e.streams?.[0]) this.callbacks.onRemoteStream?.(e.streams[0]);
+		};
+		this.pc.onicecandidate = (e) => {
+			if (e.candidate) this.send({
+				type: "ice-candidate",
+				candidate: e.candidate
+			});
+		};
+		this.pc.onconnectionstatechange = () => {
+			if (!this.pc) return;
+			const s = this.pc.connectionState;
+			this.setState(s === "connected" ? "connected" : ["connecting", "new"].includes(s) ? "connecting" : "disconnected");
+		};
+		this.handleSignalingMessage({ type: "ready" });
+		while (Date.now() < deadline) {
+			if (this.state === "connected") return;
+			await new Promise((r) => setTimeout(r, 100));
+		}
+		throw new Error("Connection timeout");
+	}
+	async handleSignalingMessage(msg) {
+		if (!this.pc) return;
+		try {
+			switch (msg.type) {
+				case "ready": {
+					await this.applyCodecPreference("video/VP8");
+					const offer = await this.pc.createOffer();
+					await this.callbacks.customizeOffer?.(offer);
+					await this.pc.setLocalDescription(offer);
+					this.send({
+						type: "offer",
+						sdp: offer.sdp || ""
+					});
+					break;
+				}
+				case "offer": {
+					await this.pc.setRemoteDescription({
+						type: "offer",
+						sdp: msg.sdp
+					});
+					const answer = await this.pc.createAnswer();
+					await this.pc.setLocalDescription(answer);
+					this.send({
+						type: "answer",
+						sdp: answer.sdp || ""
+					});
+					break;
+				}
+				case "answer":
+					await this.pc.setRemoteDescription({
+						type: "answer",
+						sdp: msg.sdp
+					});
+					break;
+				case "ice-candidate":
+					if (msg.candidate) await this.pc.addIceCandidate(msg.candidate);
+					break;
+			}
+		} catch (error) {
+			console.error("[WebRTC] Error:", error);
+			this.callbacks.onError?.(error);
+		}
+	}
+	send(message) {
+		if (this.ws?.readyState === WebSocket.OPEN) this.ws.send(JSON.stringify(message));
+	}
+	setState(state) {
+		if (this.state !== state) {
+			this.state = state;
+			console.log(`[WebRTC] State: ${state}`);
+			this.callbacks.onStateChange?.(state);
+		}
+	}
+	cleanup() {
+		this.pc?.getSenders().forEach((s) => s.track?.stop());
+		this.pc?.close();
+		this.pc = null;
+		this.ws?.close();
+		this.ws = null;
+		this.setState("disconnected");
+	}
+	async applyCodecPreference(preferredCodecName) {
+		if (!this.pc) return;
+		const videoTransceiver = this.pc.getTransceivers().find((r) => r.sender.track?.kind === "video");
+		if (!videoTransceiver) {
+			console.error("Could not find video transceiver. Ensure track is added to peer connection.");
+			return;
+		}
+		const capabilities = RTCRtpSender.getCapabilities("video");
+		if (!capabilities) {
+			console.error("Could not get video sender capabilities.");
+			return;
+		}
+		const preferredCodecs = [];
+		const otherCodecs = [];
+		capabilities.codecs.forEach((codec) => {
+			if (codec.mimeType.toLowerCase() === preferredCodecName.toLowerCase()) preferredCodecs.push(codec);
+			else otherCodecs.push(codec);
+		});
+		const orderedCodecs = [...preferredCodecs, ...otherCodecs];
+		if (orderedCodecs.length === 0) {
+			console.warn("No video codecs found to set preferences for.");
+			return;
+		}
+		await videoTransceiver.setCodecPreferences(orderedCodecs);
+	}
+};
+
+//#endregion
+export { WebRTCConnection };

package/dist/realtime/webrtc-manager.js

@@ -0,0 +1,56 @@
+import { WebRTCConnection } from "./webrtc-connection.js";
+import pRetry from "p-retry";
+
+//#region src/realtime/webrtc-manager.ts
+const PERMANENT_ERRORS = [
+	"permission denied",
+	"not allowed",
+	"invalid session"
+];
+var WebRTCManager = class {
+	connection;
+	config;
+	constructor(config) {
+		this.config = config;
+		this.connection = new WebRTCConnection({
+			onRemoteStream: config.onRemoteStream,
+			onStateChange: config.onConnectionStateChange,
+			onError: config.onError,
+			customizeOffer: config.customizeOffer
+		});
+	}
+	async connect(localStream) {
+		return pRetry(async () => {
+			await this.connection.connect(this.config.webrtcUrl, localStream);
+			return true;
+		}, {
+			retries: 5,
+			factor: 2,
+			minTimeout: 1e3,
+			maxTimeout: 1e4,
+			onFailedAttempt: (error) => {
+				console.log(`[WebRTC] Retry ${error.attemptNumber} failed: ${error.message}`);
+				this.connection.cleanup();
+			},
+			shouldRetry: (error) => {
+				const msg = error.message.toLowerCase();
+				return !PERMANENT_ERRORS.some((err) => msg.includes(err));
+			}
+		});
+	}
+	sendMessage(message) {
+		this.connection.send(message);
+	}
+	cleanup() {
+		this.connection.cleanup();
+	}
+	isConnected() {
+		return this.connection.state === "connected";
+	}
+	getConnectionState() {
+		return this.connection.state;
+	}
+};
+
+//#endregion
+export { WebRTCManager };

package/dist/shared/model.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+
+//#region src/shared/model.d.ts
+declare const realtimeModels: z.ZodUnion<readonly [z.ZodLiteral<"mirage">, z.ZodLiteral<"lucy_v2v_720p_rt">]>;
+declare const videoModels: z.ZodUnion<readonly [z.ZodLiteral<"lucy-dev-i2v">, z.ZodLiteral<"lucy-dev-v2v">, z.ZodLiteral<"lucy-pro-t2v">, z.ZodLiteral<"lucy-pro-i2v">, z.ZodLiteral<"lucy-pro-v2v">, z.ZodLiteral<"lucy-pro-flf2v">]>;
+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<"lucy_v2v_720p_rt">]>, z.ZodUnion<readonly [z.ZodLiteral<"lucy-dev-i2v">, z.ZodLiteral<"lucy-dev-v2v">, z.ZodLiteral<"lucy-pro-t2v">, z.ZodLiteral<"lucy-pro-i2v">, z.ZodLiteral<"lucy-pro-v2v">, z.ZodLiteral<"lucy-pro-flf2v">]>, 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 const modelInputSchemas: {
+  readonly "lucy-pro-t2v": z.ZodObject<{
+    prompt: z.ZodString;
+    seed: z.ZodOptional<z.ZodNumber>;
+    resolution: z.ZodOptional<z.ZodString>;
+    orientation: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  readonly "lucy-pro-t2i": z.ZodObject<{
+    prompt: z.ZodString;
+    seed: z.ZodOptional<z.ZodNumber>;
+    resolution: z.ZodOptional<z.ZodString>;
+    orientation: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  readonly "lucy-pro-i2v": z.ZodObject<{
+    prompt: z.ZodString;
+    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.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  readonly "lucy-dev-i2v": z.ZodObject<{
+    prompt: z.ZodString;
+    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.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  readonly "lucy-pro-v2v": z.ZodObject<{
+    prompt: z.ZodString;
+    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.ZodOptional<z.ZodString>;
+    enhance_prompt: z.ZodOptional<z.ZodBoolean>;
+    num_inference_steps: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>;
+  readonly "lucy-dev-v2v": z.ZodObject<{
+    prompt: z.ZodString;
+    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.ZodOptional<z.ZodString>;
+    enhance_prompt: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>;
+  readonly "lucy-pro-flf2v": z.ZodObject<{
+    prompt: z.ZodString;
+    start: z.ZodUnion<readonly [z.ZodCustom<File, File>, z.ZodCustom<Blob, Blob>, z.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>, z.ZodCustom<URL, URL>, z.ZodURL]>;
+    end: 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.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  readonly "lucy-pro-i2i": z.ZodObject<{
+    prompt: z.ZodString;
+    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.ZodOptional<z.ZodString>;
+    enhance_prompt: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>;
+};
+type ModelInputSchemas = typeof modelInputSchemas;
+type ModelDefinition<T extends Model = Model> = {
+  name: T;
+  urlPath: string;
+  fps: number;
+  width: number;
+  height: number;
+  inputSchema: T extends keyof ModelInputSchemas ? ModelInputSchemas[T] : z.ZodObject<any>;
+};
+declare const models: {
+  realtime: <T extends RealTimeModels>(model: T) => ModelDefinition<T>;
+  video: <T extends VideoModels>(model: T) => ModelDefinition<T>;
+  image: <T extends ImageModels>(model: T) => ModelDefinition<T>;
+};
+//#endregion
+export { Model, ModelDefinition, ModelInputSchemas, models };

package/dist/shared/model.js

@@ -0,0 +1,197 @@
+import { createModelNotFoundError } from "../utils/errors.js";
+import { z } from "zod";
+
+//#region src/shared/model.ts
+const realtimeModels = z.union([z.literal("mirage"), z.literal("lucy_v2v_720p_rt")]);
+const videoModels = z.union([
+	z.literal("lucy-dev-i2v"),
+	z.literal("lucy-dev-v2v"),
+	z.literal("lucy-pro-t2v"),
+	z.literal("lucy-pro-i2v"),
+	z.literal("lucy-pro-v2v"),
+	z.literal("lucy-pro-flf2v")
+]);
+const imageModels = z.union([z.literal("lucy-pro-t2i"), z.literal("lucy-pro-i2i")]);
+const modelSchema = z.union([
+	realtimeModels,
+	videoModels,
+	imageModels
+]);
+const fileInputSchema = z.union([
+	z.instanceof(File),
+	z.instanceof(Blob),
+	z.instanceof(ReadableStream),
+	z.instanceof(URL),
+	z.url()
+]);
+const modelInputSchemas = {
+	"lucy-pro-t2v": z.object({
+		prompt: z.string(),
+		seed: z.number().optional(),
+		resolution: z.string().optional(),
+		orientation: z.string().optional()
+	}),
+	"lucy-pro-t2i": z.object({
+		prompt: z.string(),
+		seed: z.number().optional(),
+		resolution: z.string().optional(),
+		orientation: z.string().optional()
+	}),
+	"lucy-pro-i2v": z.object({
+		prompt: z.string(),
+		data: fileInputSchema,
+		seed: z.number().optional(),
+		resolution: z.string().optional()
+	}),
+	"lucy-dev-i2v": z.object({
+		prompt: z.string(),
+		data: fileInputSchema,
+		seed: z.number().optional(),
+		resolution: z.string().optional()
+	}),
+	"lucy-pro-v2v": z.object({
+		prompt: z.string(),
+		data: fileInputSchema,
+		seed: z.number().optional(),
+		resolution: z.string().optional(),
+		enhance_prompt: z.boolean().optional(),
+		num_inference_steps: z.number().optional()
+	}),
+	"lucy-dev-v2v": z.object({
+		prompt: z.string(),
+		data: fileInputSchema,
+		seed: z.number().optional(),
+		resolution: z.string().optional(),
+		enhance_prompt: z.boolean().optional()
+	}),
+	"lucy-pro-flf2v": z.object({
+		prompt: z.string(),
+		start: fileInputSchema,
+		end: fileInputSchema,
+		seed: z.number().optional(),
+		resolution: z.string().optional()
+	}),
+	"lucy-pro-i2i": z.object({
+		prompt: z.string(),
+		data: fileInputSchema,
+		seed: z.number().optional(),
+		resolution: z.string().optional(),
+		enhance_prompt: z.boolean().optional()
+	})
+};
+const modelDefinitionSchema = z.object({
+	name: modelSchema,
+	urlPath: z.string(),
+	fps: z.number().min(1),
+	width: z.number().min(1),
+	height: z.number().min(1),
+	inputSchema: z.any()
+});
+const _models = {
+	realtime: {
+		mirage: {
+			urlPath: "/v1/stream",
+			name: "mirage",
+			fps: 25,
+			width: 1280,
+			height: 704,
+			inputSchema: z.object({})
+		},
+		lucy_v2v_720p_rt: {
+			urlPath: "/v1/stream",
+			name: "lucy_v2v_720p_rt",
+			fps: 25,
+			width: 1280,
+			height: 704,
+			inputSchema: z.object({})
+		}
+	},
+	image: {
+		"lucy-pro-t2i": {
+			urlPath: "/v1/generate/lucy-pro-t2i",
+			name: "lucy-pro-t2i",
+			fps: 25,
+			width: 1280,
+			height: 704,
+			inputSchema: modelInputSchemas["lucy-pro-t2i"]
+		},
+		"lucy-pro-i2i": {
+			urlPath: "/v1/generate/lucy-pro-i2i",
+			name: "lucy-pro-i2i",
+			fps: 25,
+			width: 1280,
+			height: 704,
+			inputSchema: modelInputSchemas["lucy-pro-i2i"]
+		}
+	},
+	video: {
+		"lucy-dev-i2v": {
+			urlPath: "/v1/generate/lucy-dev-i2v",
+			name: "lucy-dev-i2v",
+			fps: 25,
+			width: 1280,
+			height: 704,
+			inputSchema: modelInputSchemas["lucy-dev-i2v"]
+		},
+		"lucy-dev-v2v": {
+			urlPath: "/v1/generate/lucy-dev-v2v",
+			name: "lucy-dev-v2v",
+			fps: 25,
+			width: 1280,
+			height: 704,
+			inputSchema: modelInputSchemas["lucy-dev-v2v"]
+		},
+		"lucy-pro-t2v": {
+			urlPath: "/v1/generate/lucy-pro-t2v",
+			name: "lucy-pro-t2v",
+			fps: 25,
+			width: 1280,
+			height: 704,
+			inputSchema: modelInputSchemas["lucy-pro-t2v"]
+		},
+		"lucy-pro-i2v": {
+			urlPath: "/v1/generate/lucy-pro-i2v",
+			name: "lucy-pro-i2v",
+			fps: 25,
+			width: 1280,
+			height: 704,
+			inputSchema: modelInputSchemas["lucy-pro-i2v"]
+		},
+		"lucy-pro-v2v": {
+			urlPath: "/v1/generate/lucy-pro-v2v",
+			name: "lucy-pro-v2v",
+			fps: 25,
+			width: 1280,
+			height: 704,
+			inputSchema: modelInputSchemas["lucy-pro-v2v"]
+		},
+		"lucy-pro-flf2v": {
+			urlPath: "/v1/generate/lucy-pro-flf2v",
+			name: "lucy-pro-flf2v",
+			fps: 25,
+			width: 1280,
+			height: 704,
+			inputSchema: modelInputSchemas["lucy-pro-flf2v"]
+		}
+	}
+};
+const models = {
+	realtime: (model) => {
+		const modelDefinition = _models.realtime[model];
+		if (!modelDefinition) throw createModelNotFoundError(model);
+		return modelDefinition;
+	},
+	video: (model) => {
+		const modelDefinition = _models.video[model];
+		if (!modelDefinition) throw createModelNotFoundError(model);
+		return modelDefinition;
+	},
+	image: (model) => {
+		const modelDefinition = _models.image[model];
+		if (!modelDefinition) throw createModelNotFoundError(model);
+		return modelDefinition;
+	}
+};
+
+//#endregion
+export { modelDefinitionSchema, models };

package/dist/shared/types.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+//#region src/shared/types.d.ts
+declare const modelStateSchema: z.ZodObject<{
+  prompt: z.ZodOptional<z.ZodObject<{
+    text: z.ZodString;
+    enrich: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+  }, z.core.$strip>>;
+  mirror: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+type ModelState = z.infer<typeof modelStateSchema>;
+//#endregion
+export { ModelState };

package/dist/shared/types.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+//#region src/shared/types.ts
+const modelStateSchema = z.object({
+	prompt: z.object({
+		text: z.string().min(1),
+		enrich: z.boolean().optional().default(true)
+	}).optional(),
+	mirror: z.boolean().optional().default(false)
+});
+
+//#endregion
+export { modelStateSchema };

package/dist/utils/errors.d.ts

@@ -0,0 +1,18 @@
+//#region src/utils/errors.d.ts
+type DecartSDKError = {
+  code: string;
+  message: string;
+  data?: Record<string, unknown>;
+  cause?: Error;
+};
+declare const ERROR_CODES: {
+  readonly INVALID_API_KEY: "INVALID_API_KEY";
+  readonly INVALID_BASE_URL: "INVALID_BASE_URL";
+  readonly WEB_RTC_ERROR: "WEB_RTC_ERROR";
+  readonly PROCESSING_ERROR: "PROCESSING_ERROR";
+  readonly INVALID_INPUT: "INVALID_INPUT";
+  readonly INVALID_OPTIONS: "INVALID_OPTIONS";
+  readonly MODEL_NOT_FOUND: "MODEL_NOT_FOUND";
+};
+//#endregion
+export { DecartSDKError, ERROR_CODES };

package/dist/utils/errors.js

@@ -0,0 +1,36 @@
+//#region src/utils/errors.ts
+const ERROR_CODES = {
+	INVALID_API_KEY: "INVALID_API_KEY",
+	INVALID_BASE_URL: "INVALID_BASE_URL",
+	WEB_RTC_ERROR: "WEB_RTC_ERROR",
+	PROCESSING_ERROR: "PROCESSING_ERROR",
+	INVALID_INPUT: "INVALID_INPUT",
+	INVALID_OPTIONS: "INVALID_OPTIONS",
+	MODEL_NOT_FOUND: "MODEL_NOT_FOUND"
+};
+function createSDKError(code, message, data, cause) {
+	return {
+		code,
+		message,
+		data,
+		cause
+	};
+}
+function createInvalidApiKeyError() {
+	return createSDKError(ERROR_CODES.INVALID_API_KEY, "API key is required and must be a non-empty string");
+}
+function createInvalidBaseUrlError(url) {
+	return createSDKError(ERROR_CODES.INVALID_BASE_URL, `Invalid base URL${url ? `: ${url}` : ""}`);
+}
+function createWebrtcError(error) {
+	return createSDKError(ERROR_CODES.WEB_RTC_ERROR, "WebRTC error", { cause: error });
+}
+function createInvalidInputError(message) {
+	return createSDKError(ERROR_CODES.INVALID_INPUT, message);
+}
+function createModelNotFoundError(model) {
+	return createSDKError(ERROR_CODES.MODEL_NOT_FOUND, `Model ${model} not found`);
+}
+
+//#endregion
+export { ERROR_CODES, createInvalidApiKeyError, createInvalidBaseUrlError, createInvalidInputError, createModelNotFoundError, createSDKError, createWebrtcError };