@sogni-ai/sogni-client 4.0.0-alpha.3 → 4.0.0-alpha.31

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/SamplerParams.ts

@@ -0,0 +1,24 @@
+export const SupportedSamplers = {
+  dfs_sd3: 'Discrete Flow Scheduler (SD3)',
+  dpm_pp: 'DPM Solver Multistep (DPM-Solver++)',
+  dpm_pp_sde: 'DPM++ SDE',
+  dpm_pp_2m: 'DPM++ 2M',
+  //dpm_pp_2m_sde: 'DPM++ 2M SDE',
+  euler: 'Euler',
+  euler_a: 'Euler a',
+  //heun: 'Heun',
+  lcm: 'LCM (Latent Consistency Model)',
+  pndm_plms: 'PNDM (Pseudo-linear multi-step)'
+  //uni_pc: 'UniPC'
+};
+
+export function isSampler(sampler: string): sampler is Sampler {
+  return sampler in SupportedSamplers;
+}
+
+export function isRawSampler(sampler: string): boolean {
+  const samplers = Object.values(SupportedSamplers);
+  return samplers.includes(sampler);
+}
+
+export type Sampler = keyof typeof SupportedSamplers;

package/src/Projects/types/SchedulerParams.ts

@@ -0,0 +1,22 @@
+export const SupportedSchedulers = {
+  beta: 'Beta',
+  ddim: 'DDIM',
+  karras: 'Karras',
+  kl_optimal: 'KL Optimal',
+  leading: 'Leading',
+  linear: 'Linear',
+  normal: 'Normal',
+  sgm_uniform: 'SGM Uniform',
+  simple: 'Simple'
+};
+
+export function isScheduler(scheduler: string): scheduler is Scheduler {
+  return scheduler in SupportedSchedulers;
+}
+
+export function isRawScheduler(scheduler: string): boolean {
+  const schedulers = Object.values(SupportedSchedulers);
+  return schedulers.includes(scheduler);
+}
+
+export type Scheduler = keyof typeof SupportedSchedulers;

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,17 +1,27 @@
 import { SupernetType } from '../../ApiClient/WebSocketClient/types';
 import { ControlNetParams } from './ControlNetParams';
 import { TokenType } from '../../types/token';
+import { Sampler, SupportedSamplers } from './SamplerParams';
+import { Scheduler, SupportedSchedulers } from './SchedulerParams';
 
 export interface SupportedModel {
   id: string;
   name: string;
   SID: number;
+  /**
+   * 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 {
@@ -23,25 +33,22 @@ export interface SizePreset {
   aspect: string;
 }
 
-export type Scheduler =
-  | 'DPM Solver Multistep (DPM-Solver++)'
-  | 'PNDM (Pseudo-linear multi-step)'
-  | 'LCM (Latent Consistency Model)'
-  | 'Discrete Flow Scheduler (SD3)'
-  | 'Euler' // Used by Flux
-  | 'Euler a'; // Used by Flux
-
-export type TimeStepSpacing = 'Leading' | 'Linear' | 'Karras' | 'Simple' | 'SGM Uniform';
+export type { Sampler, Scheduler };
 
-export type OutputFormat = 'png' | 'jpg';
+export { SupportedSamplers, SupportedSchedulers };
 
-export type InputImage = File | Buffer | Blob | boolean;
+export type ImageOutputFormat = 'png' | 'jpg';
+export type VideoOutputFormat = 'mp4';
 
-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
    */
@@ -55,15 +62,15 @@ 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.
    */
-  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;
   /**
@@ -76,46 +83,102 @@ 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;
+}
+
+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';
   /**
-   * 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
+   * Number of frames to generate
    */
-  startingImage?: InputImage;
+  frames?: number;
   /**
-   * How strong effect of starting image should be. From 0 to 1, default 0.5
+   * Frames per second for output video
    */
-  startingImageStrength?: number;
+  fps?: number;
+  /**
+   * Shift parameter for video diffusion models
+   */
+  shift?: 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;
+  /**
+   * Reference video for animate workflows.
+   * Maps to: drivingVideo (animate-move), sourceVideo (animate-replace)
+   */
+  referenceVideo?: InputMedia;
+  /**
+   * Output video width. Only used if `sizePreset` is "custom"
+   */
+  width?: number;
+  /**
+   * Output video height. Only used if `sizePreset` is "custom"
+   */
+  height?: number;
+  /**
+   * 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;
   /**
-   * Context images for Flux Kontext model. Flux Kontext support up to 2 context images.
+   * 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 and Qwen Image Edit Plus support up to 3 context images.
+   * Flux Kontext supports up to 2 context images.
+   */
+  contextImages?: InputMedia[];
   /**
    * Scheduler to use
    */
-  scheduler?: Scheduler;
+  sampler?: Sampler;
   /**
    * Time step spacing method
    */
-  timeStepSpacing?: TimeStepSpacing;
+  scheduler?: Scheduler;
   /**
    * 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;
   /**
@@ -131,25 +194,59 @@ 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'
+    | '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'
@@ -202,9 +299,9 @@ export interface EstimateRequest {
    */
   guidance?: number;
   /**
-   * Scheduler
+   * Sampler
    */
-  scheduler?: Scheduler;
+  sampler?: Sampler;
   /**
    * Number of context images to use (for Flux Kontext).
    * Note that this parameter is ignored if `scheduler` is not provided
@@ -212,4 +309,41 @@ export interface EstimateRequest {
   contextImages?: number;
 }
 
+export interface VideoEstimateRequest {
+  tokenType: TokenType;
+  model: string;
+  width: number;
+  height: number;
+  frames: number;
+  fps: number;
+  steps: 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.ts

@@ -1,4 +1,4 @@
-import { EnhancementStrength } from './types';
+import { AssetRequirement, EnhancementStrength, VideoAssetKey, VideoWorkflowType } from './types';
 
 export function getEnhacementStrength(strength: EnhancementStrength): number {
   switch (strength) {
@@ -10,3 +10,68 @@ export function getEnhacementStrength(strength: EnhancementStrength): number {
       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_');
+}
+
+/**
+ * Get the video workflow type from a model ID.
+ * Returns null for non-video models.
+ */
+export function getVideoWorkflowType(modelId: string): VideoWorkflowType {
+  if (!modelId || !modelId.startsWith('wan_')) return null;
+  if (modelId.includes('_i2v')) return 'i2v';
+  if (modelId.includes('_s2v')) return 's2v';
+  if (modelId.includes('_animate-move')) return 'animate-move';
+  if (modelId.includes('_animate-replace')) return 'animate-replace';
+  if (modelId.includes('_t2v')) return 't2v';
+  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: 'required',
+    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'
+  }
+};

package/src/index.ts

@@ -14,10 +14,18 @@ import Job, { JobStatus } from './Projects/Job';
 import Project, { ProjectStatus } from './Projects/Project';
 import {
   AvailableModel,
-  OutputFormat,
+  ImageProjectParams,
+  ImageOutputFormat,
   ProjectParams,
+  Sampler,
   Scheduler,
-  TimeStepSpacing
+  SupportedSamplers,
+  SupportedSchedulers,
+  VideoProjectParams,
+  AudioFormat,
+  VideoFormat,
+  VideoOutputFormat,
+  VideoWorkflowType
 } from './Projects/types';
 // Stats API
 import StatsApi from './Stats';
@@ -28,21 +36,27 @@ import { CookieAuthManager, TokenAuthData, TokenAuthManager } from './lib/AuthMa
 import { MeData } from './Account/types';
 
 export type {
+  AudioFormat,
   AvailableModel,
   ErrorData,
+  ImageProjectParams,
+  ImageOutputFormat,
   JobStatus,
   Logger,
   LogLevel,
-  OutputFormat,
   ProjectParams,
   ProjectStatus,
-  Scheduler,
+  Sampler,
   SupernetType,
-  TimeStepSpacing,
-  TokenType
+  Scheduler,
+  TokenType,
+  VideoFormat,
+  VideoOutputFormat,
+  VideoProjectParams,
+  VideoWorkflowType
 };
 
-export { ApiError, CurrentAccount, Job, Project };
+export { ApiError, CurrentAccount, Job, Project, SupportedSamplers, SupportedSchedulers };
 
 export interface SogniClientConfig {
   /**
@@ -61,7 +75,7 @@ export interface SogniClientConfig {
   socketEndpoint?: string;
   /**
    * Disable WebSocket connection. Useful for testing or when WebSocket is not needed.
-   * Note that many may not work without WebSocket connection.
+   * Note that many APIs may not work without WebSocket connection.
    * @experimental
    * @internal
    */
@@ -93,6 +107,14 @@ export interface SogniClientConfig {
    * @experimental
    */
   authType?: 'token' | 'cookies';
+  /**
+   * Browser only. If true, the client will use a single WebSocket connection shared across multiple
+   * tabs. This is useful for browser apps that need to process multiple projects at the same time.
+   * Only works in browser environment and with cookie authentication.
+   * @default false
+   * @experimental
+   */
+  multiInstance?: boolean;
 }
 
 export class SogniClient {
@@ -139,9 +161,13 @@ export class SogniClient {
       throw Error('This method should only be called when using cookie auth');
     }
     try {
-      await this.apiClient.rest.get<ApiResponse<MeData>>('/v1/account/me');
+      const res = await this.apiClient.rest.get<ApiResponse<MeData>>('/v1/account/me');
       await auth.authenticate();
-      await this.account.me();
+      this.currentAccount._update({
+        username: res.data.username,
+        email: res.data.currentEmail,
+        walletAddress: res.data.walletAddress
+      });
       return true;
     } catch (e) {
       this.apiClient.logger.info('Client is not authenticated');
@@ -167,7 +193,8 @@ export class SogniClient {
       networkType: network,
       logger,
       authType: config.authType || 'token',
-      disableSocket: config.disableSocket
+      disableSocket: config.disableSocket,
+      multiInstance: config.multiInstance
     });
     const eip712 = new EIP712Helper({
       name: isTestnet ? 'Sogni-testnet' : 'Sogni AI',

package/src/lib/AuthManager/TokenAuthManager.ts

@@ -46,7 +46,6 @@ class TokenAuthManager extends AuthManagerBase<TokenAuthData | null> {
       const { expiresAt } = decodeToken(token);
       if (expiresAt > new Date()) {
         this._updateTokens({ token, refreshToken });
-        this.emit('updated', true);
         return;
       }
     }
@@ -55,7 +54,6 @@ class TokenAuthManager extends AuthManagerBase<TokenAuthData | null> {
     const { expiresAt: refreshExpiresAt } = decodeRefreshToken(refreshToken);
     this._refreshTokenExpiresAt = refreshExpiresAt;
     await this._renewTokenSafe();
-    this.emit('updated', true);
   }
 
   clear() {

package/src/lib/DataEntity.ts

@@ -25,9 +25,11 @@ abstract class DataEntity<D, E extends EntityEvents = EntityEvents> extends Type
   _update(delta: Partial<D>) {
     //@ts-ignore
     const changedKeys = Object.keys(delta).filter((key) => this.data[key] !== delta[key]);
-    this.data = { ...this.data, ...delta };
     this.lastUpdated = new Date();
-    this.emit('updated', changedKeys);
+    if (changedKeys.length > 0) {
+      this.data = { ...this.data, ...delta };
+      this.emit('updated', changedKeys);
+    }
   }
 
   /**

package/src/lib/validation.ts

@@ -1,7 +1,18 @@
+import { isRawSampler, isSampler, SupportedSamplers } from '../Projects/types/SamplerParams';
+import { isScheduler, SupportedSchedulers } from '../Projects/types/SchedulerParams';
+
 export function validateCustomImageSize(value: any): number {
   return validateNumber(value, { min: 256, max: 2048, propertyName: 'Width and height' });
 }
 
+/**
+ * Validate video dimensions for Wan 2.2 models.
+ * Minimum dimension is 480px for both width and height.
+ */
+export function validateVideoSize(value: any, propertyName: 'width' | 'height'): number {
+  return validateNumber(value, { min: 480, propertyName: `Video ${propertyName}` });
+}
+
 interface NumberValidationOptions {
   min?: number;
   max?: number;
@@ -38,3 +49,33 @@ export function validateNumber(
   }
   return number;
 }
+
+export function validateSampler(value?: string) {
+  if (!value) {
+    return null;
+  }
+  if (isRawSampler(value)) {
+    return value;
+  }
+  if (isSampler(value)) {
+    return SupportedSamplers[value];
+  }
+  throw new Error(
+    `Invalid sampler: ${value}. Supported options: ${Object.keys(SupportedSamplers).join(', ')}`
+  );
+}
+
+export function validateScheduler(value?: string) {
+  if (!value) {
+    return null;
+  }
+  if (isRawSampler(value)) {
+    return value;
+  }
+  if (isScheduler(value)) {
+    return SupportedSchedulers[value];
+  }
+  throw new Error(
+    `Invalid scheduler: ${value}. Supported options: ${Object.keys(SupportedSchedulers).join(', ')}`
+  );
+}