@sogni-ai/sogni-client 4.0.0-alpha.5 → 4.0.0-alpha.50

package/src/Projects/Project.ts

@@ -1,6 +1,6 @@
 import Job, { JobData } from './Job';
 import DataEntity, { EntityEvents } from '../lib/DataEntity';
-import { ProjectParams } from './types';
+import { isImageParams, ProjectParams } from './types';
 import cloneDeep from 'lodash/cloneDeep';
 import ErrorData from '../types/ErrorData';
 import getUUID from '../lib/getUUID';
@@ -8,8 +8,8 @@ import { RawJob, RawProject } from './types/RawProject';
 import ProjectsApi from './index';
 import { Logger } from '../lib/DefaultLogger';
 
-// If project is not finished and had no updates for 1 minute, force refresh
-const PROJECT_TIMEOUT = 60 * 1000;
+// If project is not finished and had no updates for 2 minutes, force refresh
+const PROJECT_TIMEOUT = 2 * 60 * 1000;
 const MAX_FAILED_SYNC_ATTEMPTS = 3;
 
 export type ProjectStatus =
@@ -39,6 +39,11 @@ export interface ProjectData {
   params: ProjectParams;
   queuePosition: number;
   status: ProjectStatus;
+  /**
+   * Estimated completion time of the project (for long-running projects like video generation).
+   * Is equal to maximum job ETA
+   */
+  eta?: Date;
   error?: ErrorData;
 }
 /** @inline */
@@ -93,10 +98,22 @@ class Project extends DataEntity<ProjectData, ProjectEventMap> {
     return this.data.params;
   }
 
+  get type() {
+    return this.params.type;
+  }
+
   get status() {
     return this.data.status;
   }
 
+  /**
+   * Estimated time of completion in seconds (for long-running projects like video generation).
+   * Updated by ComfyUI workers during inference.
+   */
+  get eta() {
+    return this.data.eta;
+  }
+
   get finished() {
     return ['completed', 'failed', 'canceled'].includes(this.status);
   }
@@ -110,10 +127,10 @@ class Project extends DataEntity<ProjectData, ProjectEventMap> {
    */
   get progress() {
     // Worker can reduce the number of steps in the job, so we need to calculate the progress based on the actual number of steps
-    const stepsPerJob = this.jobs.length ? this.jobs[0].stepCount : this.data.params.steps;
-    const jobCount = this.data.params.numberOfImages;
+    const stepsPerJob = this.jobs.length ? this.jobs[0].stepCount : (this.data.params.steps ?? 0);
+    const jobCount = this.data.params.numberOfMedia;
     const stepsDone = this._jobs.reduce((acc, job) => acc + job.step, 0);
-    return Math.round((stepsDone / (stepsPerJob * jobCount)) * 100);
+    return Math.round((stepsDone / ((stepsPerJob ?? 1) * jobCount)) * 100);
   }
 
   get queuePosition() {
@@ -156,10 +173,10 @@ class Project extends DataEntity<ProjectData, ProjectEventMap> {
     }
 
     return new Promise((resolve, reject) => {
-      this.on('completed', (images) => {
+      this.once('completed', (images) => {
         resolve(images);
       });
-      this.on('failed', (error) => {
+      this.once('failed', (error) => {
         reject(error);
       });
     });
@@ -192,7 +209,7 @@ class Project extends DataEntity<ProjectData, ProjectEventMap> {
       this._timeout = null;
     }
     if (keys.includes('status') || keys.includes('jobs')) {
-      const allJobsStarted = this.jobs.length >= this.params.numberOfImages;
+      const allJobsStarted = this.jobs.length >= this.params.numberOfMedia;
       const allJobsDone = this.jobs.every((job) => job.finished);
       if (this.data.status === 'completed' && allJobsStarted && allJobsDone) {
         return this.emit('completed', this.resultUrls);
@@ -203,6 +220,16 @@ class Project extends DataEntity<ProjectData, ProjectEventMap> {
     }
   }
 
+  /**
+   * Refresh the lastUpdated timestamp to prevent timeout.
+   * Used when receiving socket events that indicate the project is still active
+   * (e.g., jobETA events during long-running video generation).
+   * @internal
+   */
+  _keepAlive() {
+    this.lastUpdated = new Date();
+  }
+
   /**
    * This is internal method to add a job to the project. Do not call this directly.
    * @internal
@@ -231,7 +258,11 @@ class Project extends DataEntity<ProjectData, ProjectEventMap> {
   private _checkForTimeout() {
     if (this.lastUpdated.getTime() + PROJECT_TIMEOUT < Date.now()) {
       this._syncToServer().catch((error) => {
-        this._logger.error(error);
+        // 404 errors are expected when project is still initializing and not yet available via REST API
+        // Only log non-404 errors to avoid confusing users
+        if (error.status !== 404) {
+          this._logger.error(error);
+        }
         this._failedSyncAttempts++;
         if (this._failedSyncAttempts >= MAX_FAILED_SYNC_ATTEMPTS) {
           this._logger.error(
@@ -298,11 +329,13 @@ class Project extends DataEntity<ProjectData, ProjectEventMap> {
     const delta: Partial<ProjectData> = {
       params: {
         ...this.data.params,
-        numberOfImages: data.imageCount,
-        steps: data.stepCount,
-        numberOfPreviews: data.previewCount
+        numberOfMedia: data.imageCount,
+        steps: data.stepCount
       }
     };
+    if (delta.params && isImageParams(delta.params)) {
+      delta.params.numberOfPreviews = data.previewCount;
+    }
     if (PROJECT_STATUS_MAP[data.status]) {
       delta.status = PROJECT_STATUS_MAP[data.status];
     }

package/src/Projects/createJobRequestMessage.ts

@@ -1,11 +1,70 @@
-import { ProjectParams } from './types';
+import {
+  ImageProjectParams,
+  isImageParams,
+  isVideoParams,
+  ProjectParams,
+  VideoProjectParams
+} from './types';
 import { ControlNetParams, ControlNetParamsRaw } from './types/ControlNetParams';
 import {
   validateNumber,
   validateCustomImageSize,
+  validateVideoSize,
+  validateTeacacheThreshold,
+  isComfyModel,
+  validateVideoDuration,
   validateSampler,
   validateScheduler
 } from '../lib/validation';
+import { getVideoWorkflowType, isVideoModel, VIDEO_WORKFLOW_ASSETS } from './utils';
+import { ApiError } from '../ApiClient';
+import { ImageModelOptions, ModelOptions, VideoModelOptions } from './types/ModelOptions';
+
+/**
+ * Validate that the provided assets match the workflow requirements.
+ * Throws an error if required assets are missing or forbidden assets are provided.
+ */
+function validateVideoWorkflowAssets(params: VideoProjectParams): void {
+  const workflowType = getVideoWorkflowType(params.modelId);
+  if (!workflowType) return;
+
+  const requirements = VIDEO_WORKFLOW_ASSETS[workflowType];
+  if (!requirements) return;
+
+  // Special case for i2v: at least ONE of referenceImage or referenceImageEnd required
+  if (workflowType === 'i2v') {
+    if (!params.referenceImage && !params.referenceImageEnd) {
+      throw new ApiError(400, {
+        status: 'error',
+        errorCode: 0,
+        message:
+          'i2v workflow requires at least one of referenceImage or referenceImageEnd. Please provide this asset.'
+      });
+    }
+  }
+
+  // Check for missing required assets and forbidden assets
+  for (const [asset, requirement] of Object.entries(requirements)) {
+    const assetKey = asset as keyof VideoProjectParams;
+    const hasAsset = !!params[assetKey];
+
+    if (requirement === 'required' && !hasAsset) {
+      throw new ApiError(400, {
+        status: 'error',
+        errorCode: 0,
+        message: `${workflowType} workflow requires ${assetKey}. Please provide this asset.`
+      });
+    }
+
+    if (requirement === 'forbidden' && hasAsset) {
+      throw new ApiError(400, {
+        status: 'error',
+        errorCode: 0,
+        message: `${workflowType} workflow does not support ${assetKey}. Please remove this asset.`
+      });
+    }
+  }
+}
 
 // Mac worker can't process the data if some of the fields are missing, so we need to provide a default template
 function getTemplate() {
@@ -118,49 +177,190 @@ function getControlNet(params: ControlNetParams): ControlNetParamsRaw[] {
   return [cn];
 }
 
-function createJobRequestMessage(id: string, params: ProjectParams) {
+function applyImageParams(
+  inputKeyframe: Record<string, any>,
+  params: ImageProjectParams,
+  options: ImageModelOptions
+) {
+  const keyFrame: Record<string, any> = {
+    ...inputKeyframe,
+    sizePreset: params.sizePreset,
+    hasContextImage1: !!params.contextImages?.[0],
+    hasContextImage2: !!params.contextImages?.[1],
+    hasContextImage3: !!params.contextImages?.[2],
+    hasContextImage4: !!params.contextImages?.[3],
+    hasContextImage5: !!params.contextImages?.[4],
+    hasContextImage6: !!params.contextImages?.[5]
+  };
+  // Sampler/scheduler handling: SDK validates and passes through as-is.
+  // sogni-socket normalizes values for both ComfyUI and Forge workers.
+  if (isComfyModel(params.modelId)) {
+    // ComfyUI models use comfySampler/comfyScheduler fields
+    keyFrame.comfySampler = validateSampler(params.sampler, options);
+    keyFrame.comfyScheduler = validateScheduler(params.scheduler, options);
+  } else {
+    // Legacy Forge models use scheduler/timeStepSpacing fields
+    keyFrame.scheduler = validateSampler(params.sampler, options);
+    keyFrame.timeStepSpacing = validateScheduler(params.scheduler, options);
+  }
+
+  if (params.startingImage) {
+    keyFrame.hasStartingImage = true;
+    keyFrame.strengthIsEnabled = true;
+    keyFrame.strength = 1 - (Number(params.startingImageStrength) || 0.5);
+  }
+
+  if (params.controlNet) {
+    keyFrame.currentControlNetsJob = getControlNet(params.controlNet);
+  }
+
+  // Set sizePreset to 'custom' if width/height are provided but sizePreset is not set
+  let effectiveSizePreset = params.sizePreset;
+  if (params.width && params.height && !params.sizePreset) {
+    effectiveSizePreset = 'custom';
+  }
+  keyFrame.sizePreset = effectiveSizePreset;
+
+  if (effectiveSizePreset === 'custom' && params.width && params.height) {
+    keyFrame.width = validateCustomImageSize(params.width);
+    keyFrame.height = validateCustomImageSize(params.height);
+  }
+  return keyFrame;
+}
+
+function applyVideoParams(
+  inputKeyframe: Record<string, any>,
+  params: VideoProjectParams,
+  options: VideoModelOptions
+) {
+  if (!isVideoModel(params.modelId)) {
+    throw new ApiError(400, {
+      status: 'error',
+      errorCode: 0,
+      message: 'Video generation is only supported for video models.'
+    });
+  }
+  validateVideoWorkflowAssets(params);
+  const keyFrame: Record<string, any> = { ...inputKeyframe };
+  if (params.referenceImage) {
+    keyFrame.hasReferenceImage = true;
+  }
+  if (params.referenceImageEnd) {
+    keyFrame.hasReferenceImageEnd = true;
+  }
+  if (params.referenceAudio) {
+    keyFrame.hasReferenceAudio = true;
+  }
+  if (params.referenceVideo) {
+    keyFrame.hasReferenceVideo = true;
+  }
+
+  // Video generation parameters
+  if (params.frames !== undefined) {
+    keyFrame.frames = params.frames;
+  }
+  if (params.duration !== undefined) {
+    const duration = validateVideoDuration(params.duration);
+    keyFrame.frames = duration * 16 + 1;
+  }
+  if (params.fps !== undefined) {
+    keyFrame.fps = params.fps;
+  }
+  if (params.shift !== undefined) {
+    keyFrame.shift = params.shift;
+  }
+  if (params.teacacheThreshold !== undefined) {
+    const validatedThreshold = validateTeacacheThreshold(params.teacacheThreshold);
+    if (validatedThreshold !== undefined) {
+      keyFrame.teacacheThreshold = validatedThreshold;
+    }
+  }
+
+  // S2V audio parameters
+  if (params.audioStart !== undefined) {
+    keyFrame.audioStart = params.audioStart;
+  }
+  if (params.audioDuration !== undefined) {
+    keyFrame.audioDuration = params.audioDuration;
+  }
+
+  // Animate video parameters (for animate-move, animate-replace)
+  if (params.videoStart !== undefined) {
+    keyFrame.videoStart = params.videoStart;
+  }
+
+  // Validate and set video dimensions (minimum 480px for Wan 2.2 models)
+  if (params.width && params.height) {
+    keyFrame.width = validateVideoSize(params.width, 'width');
+    keyFrame.height = validateVideoSize(params.height, 'height');
+  }
+
+  keyFrame.comfySampler = validateSampler(params.sampler, options);
+  keyFrame.comfyScheduler = validateScheduler(params.scheduler, options);
+
+  return keyFrame;
+}
+
+function createJobRequestMessage(id: string, params: ProjectParams, options: ModelOptions) {
   const template = getTemplate();
+  // Base keyFrame with common params
+  let keyFrame: Record<string, any> = {
+    ...template.keyFrames[0],
+    steps: params.steps,
+    guidanceScale: params.guidance,
+    modelID: params.modelId,
+    negativePrompt: params.negativePrompt,
+    seed: params.seed,
+    positivePrompt: params.positivePrompt,
+    stylePrompt: params.stylePrompt
+  };
+
+  switch (params.type) {
+    case 'image':
+      if (options.type !== 'image') {
+        throw new ApiError(400, {
+          status: 'error',
+          errorCode: 0,
+          message:
+            'Invalid model type. Model does not support image generation. Please use a different model.'
+        });
+      }
+      keyFrame = applyImageParams(keyFrame, params, options);
+      break;
+    case 'video':
+      if (options.type !== 'video') {
+        throw new ApiError(400, {
+          status: 'error',
+          errorCode: 0,
+          message:
+            'Invalid model type. Model does not support video generation. Please use a different model.'
+        });
+      }
+      keyFrame = applyVideoParams(keyFrame, params, options);
+      break;
+    default:
+      throw new ApiError(400, {
+        status: 'error',
+        errorCode: 0,
+        message: 'Invalid project type. Must be "image" or "video".'
+      });
+  }
+
   const jobRequest: Record<string, any> = {
     ...template,
-    keyFrames: [
-      {
-        ...template.keyFrames[0],
-        scheduler: validateSampler(params.sampler),
-        timeStepSpacing: validateScheduler(params.scheduler),
-        steps: params.steps,
-        guidanceScale: params.guidance,
-        modelID: params.modelId,
-        negativePrompt: params.negativePrompt,
-        seed: params.seed,
-        positivePrompt: params.positivePrompt,
-        stylePrompt: params.stylePrompt,
-        hasStartingImage: !!params.startingImage,
-        hasContextImage1: !!params.contextImages?.[0],
-        hasContextImage2: !!params.contextImages?.[1],
-        strengthIsEnabled: !!params.startingImage,
-        strength: !!params.startingImage
-          ? 1 - (Number(params.startingImageStrength) || 0.5)
-          : undefined,
-        sizePreset: params.sizePreset
-      }
-    ],
-    previews: params.numberOfPreviews || 0,
-    numberOfImages: params.numberOfImages,
+    keyFrames: [keyFrame],
+    previews: isImageParams(params) ? params.numberOfPreviews || 0 : 0,
+    numberOfImages: params.numberOfMedia || 1,
     jobID: id,
     disableSafety: !!params.disableNSFWFilter,
     tokenType: params.tokenType,
-    outputFormat: params.outputFormat || 'png'
+    outputFormat: params.outputFormat || (isVideoParams(params) ? 'mp4' : 'png')
   };
+
   if (params.network) {
     jobRequest.network = params.network;
   }
-  if (params.controlNet) {
-    jobRequest.keyFrames[0].currentControlNetsJob = getControlNet(params.controlNet);
-  }
-  if (params.sizePreset === 'custom') {
-    jobRequest.keyFrames[0].width = validateCustomImageSize(params.width);
-    jobRequest.keyFrames[0].height = validateCustomImageSize(params.height);
-  }
+
   return jobRequest;
 }