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

package/src/Projects/types/EstimationResponse.ts

@@ -14,6 +14,8 @@ export interface Job {
   costInRenderSec: string;
   costInUSD: string;
   costInToken: string;
+  costInSpark: string;
+  costInSogni: string;
   calculatedStepCount?: number;
 }
 

package/src/Projects/types/ModelOptions.ts

@@ -0,0 +1,92 @@
+import { ComfyImageTier, ImageTier, NumericDefaults, VideoTier } from './ModelTiersRaw';
+import { samplerValueToAlias } from '../utils/samplers';
+import { schedulerValueToAlias } from '../utils/scheduler';
+
+interface NumRange {
+  min: number;
+  max: number;
+  step: number;
+  default: number;
+}
+
+interface Options<T> {
+  allowed: T[];
+  default: T | null;
+}
+
+interface NumOptions {
+  options: number[];
+  default: number;
+}
+
+export interface ImageModelOptions {
+  type: 'image';
+  steps: NumRange;
+  guidance: NumRange;
+  scheduler: Options<string>;
+  sampler: Options<string>;
+}
+
+export interface VideoModelOptions {
+  type: 'video';
+  steps: NumRange;
+  guidance: NumRange;
+  fps: Options<number>;
+  sampler: Options<string>;
+  scheduler: Options<string>;
+}
+
+export type ModelOptions = ImageModelOptions | VideoModelOptions;
+
+function mapRange(data: NumericDefaults): NumRange {
+  return {
+    min: data.min,
+    max: data.max,
+    step: data.decimals ? Math.pow(10, 0 - data.decimals) : data.step || 1,
+    default: data.default
+  };
+}
+
+function mapOptions<T>(data: Options<T> | undefined, mapper = (value: T) => value): Options<T> {
+  if (!data) {
+    return {
+      allowed: [],
+      default: null
+    };
+  }
+  return {
+    allowed: data.allowed.map(mapper),
+    default: data.default !== null ? mapper(data.default) : null
+  };
+}
+
+export function mapImageTier(tier: ImageTier): ImageModelOptions {
+  return {
+    type: 'image',
+    steps: mapRange(tier.steps),
+    guidance: mapRange(tier.guidance),
+    scheduler: mapOptions(tier.scheduler, schedulerValueToAlias),
+    sampler: mapOptions(tier.sampler, samplerValueToAlias)
+  };
+}
+
+export function mapComfyImageTier(tier: ComfyImageTier): ImageModelOptions {
+  return {
+    type: 'image',
+    steps: mapRange(tier.steps),
+    guidance: mapRange(tier.guidance),
+    scheduler: mapOptions(tier.comfyScheduler, schedulerValueToAlias),
+    sampler: mapOptions(tier.comfySampler, samplerValueToAlias)
+  };
+}
+
+export function mapVideoTier(tier: VideoTier): VideoModelOptions {
+  return {
+    type: 'video',
+    steps: mapRange(tier.steps),
+    guidance: mapRange(tier.guidance),
+    scheduler: mapOptions(tier.comfyScheduler, schedulerValueToAlias),
+    sampler: mapOptions(tier.comfySampler, samplerValueToAlias),
+    fps: tier.fps
+  };
+}

package/src/Projects/types/ModelTiersRaw.ts

@@ -0,0 +1,86 @@
+export type ModelTiersRaw = Record<string, ModelTier>;
+
+export type ModelTier = ImageTier | VideoTier | ComfyImageTier;
+
+export interface ComfyImageTier {
+  benchmark: Benchmark;
+  comfySampler: StringDefaults;
+  comfyScheduler?: StringDefaults;
+  defaultSize: number;
+  guidance: NumericDefaults;
+  steps: NumericDefaults;
+  type: 'image';
+}
+
+export function isComfyImageTier(t: ModelTier): t is ComfyImageTier {
+  return 'type' in t && t.type === 'image';
+}
+
+export interface StringDefaults {
+  allowed: string[];
+  default: string;
+}
+
+export interface NumericDefaults {
+  min: number;
+  max: number;
+  decimals?: number;
+  default: number;
+  step?: number;
+}
+
+export interface ImageTier {
+  benchmark: Benchmark;
+  guidance: NumericDefaults;
+  modelFeeUSD?: number;
+  nickname?: string;
+  scheduler: StringDefaults;
+  steps: NumericDefaults;
+  sampler: StringDefaults;
+}
+
+export function isImageTier(t: ModelTier): t is ImageTier {
+  return !Object.prototype.hasOwnProperty.call(t, 'type');
+}
+
+export interface Benchmark {
+  sec: number;
+  secContext1?: number;
+  secContext2?: number;
+  secContext3?: number;
+  secCN: number;
+  secMaxPreviews: number;
+}
+
+export interface VideoTier {
+  audioDuration?: DurationDefaults;
+  audioStart?: DurationDefaults;
+  benchmark: Benchmark;
+  comfySampler: StringDefaults;
+  comfyScheduler: StringDefaults;
+  fps: NumericOptions;
+  frames: NumericDefaults;
+  guidance: NumericDefaults;
+  height: NumericDefaults;
+  shift: NumericDefaults;
+  steps: NumericDefaults;
+  type: 'video';
+  videoStart?: DurationDefaults;
+  width: NumericDefaults;
+}
+
+export function isVideoTier(t: ModelTier): t is VideoTier {
+  return 'type' in t && t.type === 'video';
+}
+
+export interface DurationDefaults {
+  min: number;
+  default: number;
+}
+
+export interface NumericOptions {
+  allowed: number[];
+  default: number;
+}
+
+export default ModelTiersRaw;

package/src/Projects/types/events.ts

@@ -48,6 +48,11 @@ export interface JobProgress extends JobEventBase {
   stepCount: number;
 }
 
+export interface JobETA extends JobEventBase {
+  type: 'jobETA';
+  etaSeconds: number;
+}
+
 export interface JobPreview extends JobEventBase {
   type: 'preview';
   url: string;
@@ -75,6 +80,7 @@ export type JobEvent =
   | JobInitiating
   | JobStarted
   | JobProgress
+  | JobETA
   | JobPreview
   | JobCompleted
   | JobError;

package/src/Projects/types/index.ts

@@ -1,19 +1,26 @@
 import { SupernetType } from '../../ApiClient/WebSocketClient/types';
 import { ControlNetParams } from './ControlNetParams';
 import { TokenType } from '../../types/token';
-import { Sampler } from './SamplerParams';
-import { Scheduler } from './SchedulerParams';
 
 export interface SupportedModel {
   id: string;
   name: string;
   SID: number;
+  tier: string;
+  /**
+   * Media type produced by this model: 'image' or 'video'
+   */
+  media: 'image' | 'video';
 }
 
 export interface AvailableModel {
   id: string;
   name: string;
   workerCount: number;
+  /**
+   * Media type produced by this model: 'image' or 'video'
+   */
+  media: 'image' | 'video';
 }
 
 export interface SizePreset {
@@ -25,17 +32,18 @@ export interface SizePreset {
   aspect: string;
 }
 
-export type { Sampler, Scheduler };
+export type ImageOutputFormat = 'png' | 'jpg';
+export type VideoOutputFormat = 'mp4';
 
-export type OutputFormat = 'png' | 'jpg';
-
-export type InputImage = File | Buffer | Blob | boolean;
-
-export interface ProjectParams {
+export interface BaseProjectParams {
   /**
    * ID of the model to use, available models are available in the `availableModels` property of the `ProjectsApi` instance.
    */
   modelId: string;
+  /**
+   * Number of media files to generate. Depending on project type, this can be number of images or number of videos.
+   */
+  numberOfMedia: number;
   /**
    * Prompt for what to be created
    */
@@ -49,15 +57,17 @@ export interface ProjectParams {
    */
   stylePrompt: string;
   /**
-   * Number of steps. For most Stable Diffusion models, optimal value is 20
+   * Number of steps. For most Stable Diffusion models, optimal value is 20.
    */
-  steps: number;
+  steps?: number;
   /**
-   * Guidance scale. For most Stable Diffusion models, optimal value is 7.5
+   * Guidance scale. For most Stable Diffusion models, optimal value is 7.5.
+   * For video models: Regular models range 0.7-8.0, LoRA version (lightx2v) range 0.7-1.6, step 0.01.
+   * This maps to `guidanceScale` in the keyFrame for both image and video models.
    */
-  guidance: number;
+  guidance?: number;
   /**
-   * Override current network type. Default value can be read from `client.account.currentAccount.network`
+   * Override current network type. Default value can be read from `sogni.account.currentAccount.network`
    */
   network?: SupernetType;
   /**
@@ -70,46 +80,164 @@ export interface ProjectParams {
    */
   seed?: number;
   /**
-   * Number of images to generate
+   * Select which tokens to use for the project.
+   * If not specified, the Sogni token will be used.
    */
-  numberOfImages: number;
+  tokenType?: TokenType;
   /**
-   * Generate images based on the starting image.
-   * Supported types:
-   * `File` - file object from input[type=file]
-   * `Buffer` - Node.js buffer object with image data
-   * `Blob` - blob object with image data
-   * `true` - indicates that the image is already uploaded to the server
+   * LoRA ID to use for generation.
+   * Available LoRAs are model-specific. The worker will download the LoRA
+   * if not already present on the persistent volume.
    */
-  startingImage?: InputImage;
+  loraId?: string;
   /**
-   * How strong effect of starting image should be. From 0 to 1, default 0.5
+   * Array of LoRA filenames to apply (for Qwen Image Edit workflows).
+   * Filenames should end with .safetensors.
+   * Example: ['qwen-image-edit-2511-multiple-angles-lora.safetensors']
    */
-  startingImageStrength?: number;
+  loras?: string[];
+  /**
+   * Array of LoRA strengths corresponding to each LoRA in the loras array.
+   * Values should be between 0.0 and 2.0. Defaults to 1.0 if not specified.
+   * Example: [0.9]
+   */
+  loraStrengths?: number[];
+}
+
+export type InputMedia = File | Buffer | Blob | boolean;
+
+/**
+ * Video-specific parameters for video workflows (t2v, i2v, s2v, animate).
+ * Only applicable when using video models like wan_v2.2-14b-fp8_t2v.
+ * Includes frame count, fps, shift, and reference assets (image, audio, video).
+ */
+export interface VideoProjectParams extends BaseProjectParams {
+  type: 'video';
+  /**
+   * Number of frames to generate
+   * @deprecated Use duration instead
+   */
+  frames?: number;
+  /**
+   * Duration of the video in seconds. Supported range 1 to 10
+   */
+  duration?: number;
+  /**
+   * Frames per second for output video
+   */
+  fps?: number;
+  /**
+   * Shift parameter for video diffusion models.
+   * Controls motion intensity. Range: 1.0-8.0, step 0.1.
+   * Default: 8.0 for regular models, 5.0 for speed lora (lightx2v) except s2v and animate which use 8.0
+   */
+  shift?: number;
+  /**
+   * TeaCache optimization threshold for T2V and I2V models.
+   * Range: 0.0-1.0. 0.0 = disabled.
+   * Recommended: 0.15 for T2V (~1.5x speedup), 0.2 for I2V (conservative quality-focused)
+   */
+  teacacheThreshold?: number;
+  /**
+   * Reference image for WAN video workflows.
+   * Maps to: startImage (i2v), characterImage (animate), referenceImage (s2v)
+   */
+  referenceImage?: InputMedia;
+  /**
+   * Optional end image for i2v interpolation workflows.
+   * When provided with referenceImage, the video will interpolate between the two images.
+   */
+  referenceImageEnd?: InputMedia;
+  /**
+   * Reference audio for s2v (sound-to-video) workflows.
+   */
+  referenceAudio?: InputMedia;
+  /**
+   * Audio start position in seconds for s2v workflows.
+   * Specifies where to begin reading from the audio file.
+   * Default: 0
+   */
+  audioStart?: number;
+  /**
+   * Audio duration in seconds for s2v workflows.
+   * Specifies how many seconds of audio to use.
+   * If not provided, defaults to 30 seconds on the server.
+   */
+  audioDuration?: number;
+  /**
+   * Reference video for animate workflows.
+   * Maps to: drivingVideo (animate-move), sourceVideo (animate-replace)
+   */
+  referenceVideo?: InputMedia;
+  /**
+   * Video start position in seconds for animate workflows (animate-move, animate-replace).
+   * Specifies where to begin reading from the reference video file.
+   * Default: 0
+   */
+  videoStart?: number;
   /**
-   * Context images for Flux Kontext model. Flux Kontext support up to 2 context images.
+   * Output video width. Only used if `sizePreset` is "custom"
+   */
+  width?: number;
+  /**
+   * Output video height. Only used if `sizePreset` is "custom"
+   */
+  height?: number;
+  /**
+   * Sampler, available options depend on the model. Use `sogni.projects.getModelOptions(modelId)`
+   * to get the list of available samplers.
+   */
+  sampler?: string;
+  /**
+   * Scheduler, available options depend on the model. Use `sogni.projects.getModelOptions(modelId)`
+   * to get the list of available schedulers.
+   */
+  scheduler?: string;
+  /**
+   * Output video format. For now only 'mp4' is supported, defaults to 'mp4'.
+   */
+  outputFormat?: VideoOutputFormat;
+}
+
+export interface ImageProjectParams extends BaseProjectParams {
+  type: 'image';
+  /**
+   * Number of previews to generate. Note that previews affect project cost
+   */
+  numberOfPreviews?: number;
+  /**
+   * Starting image for img2img workflows.
    * Supported types:
    * `File` - file object from input[type=file]
    * `Buffer` - Node.js buffer object with image data
    * `Blob` - blob object with image data
    * `true` - indicates that the image is already uploaded to the server
    */
-  contextImages?: InputImage[];
+  startingImage?: InputMedia;
   /**
-   * Number of previews to generate. Note that previews affect project cost\
+   * How strong effect of starting image should be. From 0 to 1, default 0.5
    */
-  numberOfPreviews?: number;
+  startingImageStrength?: number;
+  /**
+   * Context images for multi-reference image generation.
+   * Flux.2 Dev supports up to 6 context images.
+   * Qwen Image Edit Plus supports up to 3 context images.
+   * Flux Kontext supports up to 2 context images.
+   */
+  contextImages?: InputMedia[];
   /**
-   * Scheduler to use
+   * Sampler, available options depend on the model. Use `sogni.projects.getModelOptions(modelId)`
+   * to get the list of available samplers.
    */
-  sampler?: Sampler;
+  sampler?: string;
   /**
-   * Time step spacing method
+   * Scheduler, available options depend on the model. Use `sogni.projects.getModelOptions(modelId)`
+   * to get the list of available schedulers.
    */
-  scheduler?: Scheduler;
+  scheduler?: string;
   /**
    * Size preset ID to use. You can query available size presets
-   * from `client.projects.sizePresets(network, modelId)`
+   * from `sogni.projects.sizePresets(network, modelId)`
    */
   sizePreset?: 'custom' | string;
   /**
@@ -125,25 +253,62 @@ export interface ProjectParams {
    */
   controlNet?: ControlNetParams;
   /**
-   * Select which tokens to use for the project.
-   * If not specified, the Sogni token will be used.
-   */
-  tokenType?: TokenType;
-  /**
-   * Output image format. Can be 'png' or 'jpg'.
-   * If not specified, 'png' will be used.
+   * Output format. Can be 'png' or 'jpg'. Defaults to 'png'.
    */
-  outputFormat?: OutputFormat;
+  outputFormat?: ImageOutputFormat;
+}
+
+export type ProjectParams = ImageProjectParams | VideoProjectParams;
+
+export function isVideoParams(params: ProjectParams): params is VideoProjectParams {
+  return params.type === 'video';
+}
+
+export function isImageParams(params: ProjectParams): params is ImageProjectParams {
+  return params.type === 'image';
 }
 
+/**
+ * Supported audio formats
+ */
+export type AudioFormat = 'm4a' | 'mp3' | 'wav';
+
+/**
+ * Supported video formats
+ */
+export type VideoFormat = 'mp4' | 'mov';
+
+/**
+ * Parameters for image asset URL requests (upload/download)
+ */
 export type ImageUrlParams = {
   imageId: string;
   jobId: string;
-  type: 'preview' | 'complete' | 'startingImage' | 'cnImage' | 'contextImage1' | 'contextImage2';
-  // This seems to be unused currently
+  type:
+    | 'preview'
+    | 'complete'
+    | 'startingImage'
+    | 'cnImage'
+    | 'contextImage1'
+    | 'contextImage2'
+    | 'contextImage3'
+    | 'contextImage4'
+    | 'contextImage5'
+    | 'contextImage6'
+    | 'referenceImage'
+    | 'referenceImageEnd';
   startContentType?: string;
 };
 
+/**
+ * Parameters for media asset URL requests (video/audio upload/download)
+ */
+export type MediaUrlParams = {
+  id?: string;
+  jobId: string;
+  type: 'complete' | 'preview' | 'referenceAudio' | 'referenceVideo';
+};
+
 export interface EstimateRequest {
   /**
    * Network to use. Can be 'fast' or 'relaxed'
@@ -196,9 +361,9 @@ export interface EstimateRequest {
    */
   guidance?: number;
   /**
-   * Scheduler
+   * Sampler
    */
-  scheduler?: Sampler;
+  sampler?: string;
   /**
    * Number of context images to use (for Flux Kontext).
    * Note that this parameter is ignored if `scheduler` is not provided
@@ -206,4 +371,47 @@ export interface EstimateRequest {
   contextImages?: number;
 }
 
+export interface VideoEstimateRequest {
+  tokenType: TokenType;
+  model: string;
+  width: number;
+  height: number;
+  duration: number;
+  /**
+   * Number of frames to generate.
+   * @deprecated Use duration instead
+   */
+  frames?: number;
+  fps: number;
+  steps: number;
+  numberOfMedia: number;
+}
+
+/**
+ * Represents estimation of project cost in different currency formats
+ */
+export interface CostEstimation {
+  /** Cost in selected token type */
+  token: string;
+  /** Cost in USD */
+  usd: string;
+  /** Cost in Spark Points */
+  spark: string;
+  /** Cost in Sogni tokens */
+  sogni: string;
+}
+
 export type EnhancementStrength = 'light' | 'medium' | 'heavy';
+
+/**
+ * Video workflow types for WAN models
+ */
+export type VideoWorkflowType = 't2v' | 'i2v' | 's2v' | 'animate-move' | 'animate-replace' | null;
+
+export type AssetRequirement = 'required' | 'optional' | 'forbidden';
+
+export type VideoAssetKey =
+  | 'referenceImage'
+  | 'referenceImageEnd'
+  | 'referenceAudio'
+  | 'referenceVideo';

package/src/Projects/utils/index.ts

@@ -0,0 +1,90 @@
+import { AssetRequirement, EnhancementStrength, VideoAssetKey, VideoWorkflowType } from '../types';
+
+export function getEnhacementStrength(strength: EnhancementStrength): number {
+  switch (strength) {
+    case 'light':
+      return 0.15;
+    case 'heavy':
+      return 0.49;
+    default:
+      return 0.35;
+  }
+}
+
+/**
+ * Check if a model ID is for a video workflow.
+ * This is consistent with the `media` property returned by the models list API.
+ * Video models produce MP4 output; image models produce PNG/JPG output.
+ */
+export function isVideoModel(modelId: string): boolean {
+  return modelId.startsWith('wan_') || modelId.startsWith('ltx2-');
+}
+
+/**
+ * Get the video workflow type from a model ID.
+ * Returns null for non-video models.
+ */
+export function getVideoWorkflowType(modelId: string): VideoWorkflowType {
+  if (!modelId) return null;
+
+  // Check for supported video model prefixes
+  const isWan = modelId.startsWith('wan_');
+  const isLtx2 = modelId.startsWith('ltx2-');
+
+  if (!isWan && !isLtx2) return null;
+
+  // WAN and LTX-2 models share similar workflow type suffixes
+  if (modelId.includes('_i2v')) return 'i2v';
+  if (modelId.includes('_t2v')) return 't2v';
+
+  // WAN-specific workflow types
+  if (isWan) {
+    if (modelId.includes('_s2v')) return 's2v';
+    if (modelId.includes('_animate-move')) return 'animate-move';
+    if (modelId.includes('_animate-replace')) return 'animate-replace';
+  }
+
+  return null;
+}
+
+/**
+ * Asset requirements for each video workflow type.
+ * - required: Must be provided
+ * - optional: Can be provided
+ * - forbidden: Must NOT be provided
+ */
+export const VIDEO_WORKFLOW_ASSETS: Record<
+  NonNullable<VideoWorkflowType>,
+  Record<VideoAssetKey, AssetRequirement>
+> = {
+  t2v: {
+    referenceImage: 'forbidden',
+    referenceImageEnd: 'forbidden',
+    referenceAudio: 'forbidden',
+    referenceVideo: 'forbidden'
+  },
+  i2v: {
+    referenceImage: 'optional',
+    referenceImageEnd: 'optional',
+    referenceAudio: 'forbidden',
+    referenceVideo: 'forbidden'
+  },
+  s2v: {
+    referenceImage: 'required',
+    referenceAudio: 'required',
+    referenceImageEnd: 'forbidden',
+    referenceVideo: 'forbidden'
+  },
+  'animate-move': {
+    referenceImage: 'required',
+    referenceVideo: 'required',
+    referenceImageEnd: 'forbidden',
+    referenceAudio: 'forbidden'
+  },
+  'animate-replace': {
+    referenceImage: 'required',
+    referenceVideo: 'required',
+    referenceImageEnd: 'forbidden',
+    referenceAudio: 'forbidden'
+  }
+};