@sogni-ai/sogni-client 4.0.0-alpha.45 → 4.0.0-alpha.46

package/src/Projects/createJobRequestMessage.ts

@@ -9,17 +9,16 @@ import { ControlNetParams, ControlNetParamsRaw } from './types/ControlNetParams'
 import {
   validateNumber,
   validateCustomImageSize,
-  validateForgeSampler,
-  validateForgeScheduler,
   validateVideoSize,
   validateTeacacheThreshold,
-  validateComfySampler,
-  validateComfyScheduler,
   isComfyModel,
-  validateVideoDuration
+  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.
@@ -178,7 +177,11 @@ function getControlNet(params: ControlNetParams): ControlNetParamsRaw[] {
   return [cn];
 }
 
-function applyImageParams(inputKeyframe: Record<string, any>, params: ImageProjectParams) {
+function applyImageParams(
+  inputKeyframe: Record<string, any>,
+  params: ImageProjectParams,
+  options: ImageModelOptions
+) {
   const keyFrame: Record<string, any> = {
     ...inputKeyframe,
     sizePreset: params.sizePreset,
@@ -189,23 +192,12 @@ function applyImageParams(inputKeyframe: Record<string, any>, params: ImageProje
     hasContextImage5: !!params.contextImages?.[4],
     hasContextImage6: !!params.contextImages?.[5]
   };
-
-  // Handle sampler/scheduler: ComfyUI models use comfySampler/comfyScheduler,
-  // legacy models use sampler/scheduler (mapped to scheduler/timeStepSpacing)
   if (isComfyModel(params.modelId)) {
-    if (params.sampler !== undefined) {
-      keyFrame.comfySampler = validateComfySampler(params.sampler);
-    }
-    if (params.scheduler !== undefined) {
-      keyFrame.comfyScheduler = validateComfyScheduler(params.scheduler);
-    }
+    keyFrame.comfySampler = validateSampler(params.sampler, options);
+    keyFrame.comfyScheduler = validateScheduler(params.scheduler, options);
   } else {
-    if (params.sampler !== undefined) {
-      keyFrame.scheduler = validateForgeSampler(params.sampler);
-    }
-    if (params.scheduler !== undefined) {
-      keyFrame.timeStepSpacing = validateForgeScheduler(params.scheduler);
-    }
+    keyFrame.scheduler = validateSampler(params.sampler, options);
+    keyFrame.timeStepSpacing = validateScheduler(params.scheduler, options);
   }
 
   if (params.startingImage) {
@@ -232,7 +224,11 @@ function applyImageParams(inputKeyframe: Record<string, any>, params: ImageProje
   return keyFrame;
 }
 
-function applyVideoParams(inputKeyframe: Record<string, any>, params: VideoProjectParams) {
+function applyVideoParams(
+  inputKeyframe: Record<string, any>,
+  params: VideoProjectParams,
+  options: VideoModelOptions
+) {
   if (!isVideoModel(params.modelId)) {
     throw new ApiError(400, {
       status: 'error',
@@ -295,19 +291,13 @@ function applyVideoParams(inputKeyframe: Record<string, any>, params: VideoProje
     keyFrame.height = validateVideoSize(params.height, 'height');
   }
 
-  // Video models are ComfyUI models - only accept comfySampler/comfyScheduler
-  // Legacy sampler/scheduler fields are NOT supported for video models
-  if (params.sampler !== undefined) {
-    keyFrame.comfySampler = validateComfySampler(params.sampler);
-  }
-  if (params.scheduler !== undefined) {
-    keyFrame.comfyScheduler = validateComfyScheduler(params.scheduler);
-  }
+  keyFrame.comfySampler = validateSampler(params.sampler, options);
+  keyFrame.comfyScheduler = validateScheduler(params.scheduler, options);
 
   return keyFrame;
 }
 
-function createJobRequestMessage(id: string, params: ProjectParams) {
+function createJobRequestMessage(id: string, params: ProjectParams, options: ModelOptions) {
   const template = getTemplate();
   // Base keyFrame with common params
   let keyFrame: Record<string, any> = {
@@ -323,10 +313,26 @@ function createJobRequestMessage(id: string, params: ProjectParams) {
 
   switch (params.type) {
     case 'image':
-      keyFrame = applyImageParams(keyFrame, params);
+      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':
-      keyFrame = applyVideoParams(keyFrame, params);
+      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, {

package/src/Projects/index.ts

@@ -11,15 +11,7 @@ import {
   SupportedModel,
   ImageProjectParams,
   VideoProjectParams,
-  VideoEstimateRequest,
-  SupportedComfySamplers,
-  SupportedForgeSamplers,
-  SupportedComfySchedulers,
-  SupportedForgeSchedulers,
-  ComfyScheduler,
-  ForgeScheduler,
-  ComfySampler,
-  ForgeSampler
+  VideoEstimateRequest
 } from './types';
 import {
   JobErrorData,
@@ -47,7 +39,9 @@ import {
   VIDEO_WORKFLOW_ASSETS
 } from './utils';
 import { TokenType } from '../types/token';
-import { isComfyModel, validateSampler } from '../lib/validation';
+import { validateSampler } from '../lib/validation';
+import ModelTiersRaw, { isComfyImageTier, isImageTier, isVideoTier } from './types/ModelTiersRaw';
+import { mapComfyImageTier, mapImageTier, mapVideoTier, ModelOptions } from './types/ModelOptions';
 
 const sizePresetCache = new Cache<SizePreset[]>(10 * 60 * 1000);
 const GARBAGE_COLLECT_TIMEOUT = 30000;
@@ -106,6 +100,13 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
     data: null,
     updatedAt: new Date(0)
   };
+  private _modelTiers: {
+    data: ModelTiersRaw;
+    updatedAt: Date;
+  } = {
+    data: {},
+    updatedAt: new Date(0)
+  };
 
   get availableModels() {
     return this._availableModels;
@@ -524,7 +525,8 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
    */
   async create(data: ProjectParams): Promise<Project> {
     const project = new Project({ ...data }, { api: this, logger: this.client.logger });
-    const request = createJobRequestMessage(project.id, data);
+    const modelOptions = await this.getModelOptions(data.modelId);
+    const request = createJobRequestMessage(project.id, data, modelOptions);
 
     switch (data.type) {
       case 'image':
@@ -833,6 +835,7 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
     contextImages
   }: EstimateRequest): Promise<CostEstimation> {
     let apiVersion = 2;
+    const modelOptions = await this.getModelOptions(model);
     const pathParams = [
       tokenType || 'spark',
       network,
@@ -858,7 +861,7 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
     if (sampler) {
       apiVersion = 3;
       pathParams.push(guidance || 0);
-      pathParams.push(validateSampler(model, sampler)!);
+      pathParams.push(validateSampler(sampler, modelOptions)!);
       pathParams.push(contextImages || 0);
     }
     const r = await this.client.socket.get<EstimationResponse>(
@@ -1005,6 +1008,19 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
     return models;
   }
 
+  private async _getModelTiers(forceRefresh = false) {
+    if (
+      this._modelTiers.data &&
+      !forceRefresh &&
+      Date.now() - this._modelTiers.updatedAt.getTime() < MODELS_REFRESH_INTERVAL
+    ) {
+      return this._modelTiers.data;
+    }
+    const tiers = await this.client.socket.get<ModelTiersRaw>(`/api/v2/models/tiers`);
+    this._modelTiers = { data: tiers, updatedAt: new Date() };
+    return tiers;
+  }
+
   /**
    * Get supported size presets for the model and network. Size presets are cached for 10 minutes.
    *
@@ -1104,18 +1120,27 @@ class ProjectsApi extends ApiGroup<ProjectApiEvents> {
     });
   }
 
-  async getSamplers(modelId: string) {
-    if (isComfyModel(modelId)) {
-      return Object.keys(SupportedComfySamplers) as ComfySampler[];
+  async getModelOptions(modelId: string): Promise<ModelOptions> {
+    const models = await this.getSupportedModels();
+    const tiers = await this._getModelTiers();
+    const model = models.find((m) => m.id === modelId);
+    if (!model) {
+      throw new Error(`Model ${modelId} not supported`);
     }
-    return Object.keys(SupportedForgeSamplers) as ForgeSampler[];
-  }
-
-  async getSchedulers(modelId: string) {
-    if (isComfyModel(modelId)) {
-      return Object.keys(SupportedComfySchedulers) as ComfyScheduler[];
+    const tier = tiers[model.tier];
+    if (!tier) {
+      throw new Error(`Unable to find model tier "${model.tier}" please contact support`);
+    }
+    if (isImageTier(tier)) {
+      return mapImageTier(tier);
+    }
+    if (isVideoTier(tier)) {
+      return mapVideoTier(tier);
+    }
+    if (isComfyImageTier(tier)) {
+      return mapComfyImageTier(tier);
     }
-    return Object.keys(SupportedForgeSchedulers) as ForgeScheduler[];
+    throw new Error(`Unsupported model tier "${model.tier}"`);
   }
 }
 

package/src/Projects/types/ComfySamplerParams.ts

@@ -1,34 +0,0 @@
-/**
- * ComfyUI sampler parameters for video models and ComfyUI-based image models.
- * These use lowercase underscore format directly matching ComfyUI's internal names.
- */
-export const SupportedComfySamplers = {
-  euler: 'euler',
-  euler_ancestral: 'euler_ancestral',
-  heun: 'heun',
-  dpmpp_2m: 'dpmpp_2m',
-  dpmpp_2m_sde: 'dpmpp_2m_sde',
-  dpmpp_sde: 'dpmpp_sde',
-  dpmpp_3m_sde: 'dpmpp_3m_sde',
-  uni_pc: 'uni_pc',
-  lcm: 'lcm',
-  // Additional ComfyUI samplers
-  lms: 'lms',
-  dpm_2: 'dpm_2',
-  dpm_2_ancestral: 'dpm_2_ancestral',
-  dpm_fast: 'dpm_fast',
-  dpm_adaptive: 'dpm_adaptive',
-  dpmpp_2s_ancestral: 'dpmpp_2s_ancestral',
-  ddpm: 'ddpm',
-  ddim: 'ddim',
-  uni_pc_bh2: 'uni_pc_bh2',
-  // Z-Image specific samplers
-  res_multistep: 'res_multistep',
-  res_multistep_cfg_pp: 'res_multistep_cfg_pp'
-};
-
-export function isComfySampler(sampler: string): sampler is ComfySampler {
-  return sampler in SupportedComfySamplers;
-}
-
-export type ComfySampler = keyof typeof SupportedComfySamplers;

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

@@ -1,15 +1,12 @@
 import { SupernetType } from '../../ApiClient/WebSocketClient/types';
 import { ControlNetParams } from './ControlNetParams';
 import { TokenType } from '../../types/token';
-import { ForgeSampler, SupportedForgeSamplers } from './ForgeSamplerParams';
-import { ForgeScheduler, SupportedForgeSchedulers } from './ForgeSchedulerParams';
-import { ComfySampler, SupportedComfySamplers } from './ComfySamplerParams';
-import { ComfyScheduler, SupportedComfySchedulers } from './ComfySchedulerParams';
 
 export interface SupportedModel {
   id: string;
   name: string;
   SID: number;
+  tier: string;
   /**
    * Media type produced by this model: 'image' or 'video'
    */
@@ -35,19 +32,6 @@ export interface SizePreset {
   aspect: string;
 }
 
-export type Sampler = ForgeSampler | ComfySampler;
-
-export type Scheduler = ForgeScheduler | ComfyScheduler;
-
-export type { ForgeSampler, ForgeScheduler, ComfySampler, ComfyScheduler };
-
-export {
-  SupportedForgeSamplers,
-  SupportedForgeSchedulers,
-  SupportedComfySamplers,
-  SupportedComfySchedulers
-};
-
 export type ImageOutputFormat = 'png' | 'jpg';
 export type VideoOutputFormat = 'mp4';
 
@@ -182,17 +166,15 @@ export interface VideoProjectParams extends BaseProjectParams {
    */
   height?: number;
   /**
-   * ComfyUI sampler for video generation.
-   * Uses ComfyUI's native lowercase format: euler, euler_ancestral, dpmpp_2m, etc.
-   * Default: euler (or uni_pc for s2v models)
+   * Sampler, available options depend on the model. Use `sogni.projects.getModelOptions(modelId)`
+   * to get the list of available samplers.
    */
-  sampler?: ComfySampler;
+  sampler?: string;
   /**
-   * ComfyUI scheduler for video generation.
-   * Uses ComfyUI's native lowercase format: simple, normal, karras, sgm_uniform, etc.
-   * Default: simple
+   * Scheduler, available options depend on the model. Use `sogni.projects.getModelOptions(modelId)`
+   * to get the list of available schedulers.
    */
-  scheduler?: ComfyScheduler;
+  scheduler?: string;
   /**
    * Output video format. For now only 'mp4' is supported, defaults to 'mp4'.
    */
@@ -225,15 +207,15 @@ export interface ImageProjectParams extends BaseProjectParams {
    */
   contextImages?: InputMedia[];
   /**
-   * Legacy sampler for non-ComfyUI models (Automatic1111 workers).
-   * Not supported for ComfyUI models - use comfySampler instead.
+   * Sampler, available options depend on the model. Use `sogni.projects.getModelOptions(modelId)`
+   * to get the list of available samplers.
    */
-  sampler?: Sampler;
+  sampler?: string;
   /**
-   * Legacy scheduler for non-ComfyUI models (Automatic1111 workers).
-   * Not supported for ComfyUI models - use comfyScheduler instead.
+   * 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 `sogni.projects.sizePresets(network, modelId)`
@@ -362,7 +344,7 @@ export interface EstimateRequest {
   /**
    * Sampler
    */
-  sampler?: Sampler;
+  sampler?: string;
   /**
    * Number of context images to use (for Flux Kontext).
    * Note that this parameter is ignored if `scheduler` is not provided

package/src/Projects/{utils.ts → utils/index.ts}

@@ -1,4 +1,4 @@
-import { AssetRequirement, EnhancementStrength, VideoAssetKey, VideoWorkflowType } from './types';
+import { AssetRequirement, EnhancementStrength, VideoAssetKey, VideoWorkflowType } from '../types';
 
 export function getEnhacementStrength(strength: EnhancementStrength): number {
   switch (strength) {

package/src/Projects/{types/ForgeSamplerParams.ts → utils/samplers.ts}

@@ -1,4 +1,4 @@
-export const SupportedForgeSamplers = {
+const SamplerAliases: Record<string, string> = {
   euler: 'Euler',
   euler_ancestral: 'Euler Ancestral',
   heun: 'Heun',
@@ -25,13 +25,14 @@ export const SupportedForgeSamplers = {
   pndm_plms: 'PNDM (Pseudo-linear multi-step)'
 };
 
-export function isForgeSampler(sampler: string): sampler is ForgeSampler {
-  return sampler in SupportedForgeSamplers;
-}
+const SamplerValueToAlias = Object.fromEntries(
+  Object.entries(SamplerAliases).map(([k, v]) => [v, k])
+);
 
-export function isRawForgeSampler(sampler: string): boolean {
-  const samplers = Object.values(SupportedForgeSamplers);
-  return samplers.includes(sampler);
+export function samplerAliasToValue(alias: string): string {
+  return SamplerAliases[alias] || alias;
 }
 
-export type ForgeSampler = keyof typeof SupportedForgeSamplers;
+export function samplerValueToAlias(value: string): string {
+  return SamplerValueToAlias[value] || value;
+}

package/src/Projects/utils/scheduler.ts

@@ -0,0 +1,27 @@
+const SchedulerAliases: Record<string, string> = {
+  simple: 'Simple',
+  normal: 'Normal',
+  karras: 'Karras',
+  exponential: 'Exponential',
+  sgm_uniform: 'SGM Uniform',
+  ddim_uniform: 'DDIM Uniform',
+  beta: 'Beta',
+  linear_quadratic: 'Linear Quadratic',
+  kl_optimal: 'KL Optimal',
+  // Legacy aliases
+  ddim: 'DDIM',
+  leading: 'Leading',
+  linear: 'Linear'
+};
+
+const SchedulerValueToAlias = Object.fromEntries(
+  Object.entries(SchedulerAliases).map(([k, v]) => [v, k])
+);
+
+export function schedulerAliasToValue(alias: string): string {
+  return SchedulerAliases[alias] || alias;
+}
+
+export function schedulerValueToAlias(value: string): string {
+  return SchedulerValueToAlias[value] || value;
+}

package/src/index.ts

@@ -17,16 +17,6 @@ import {
   ImageProjectParams,
   ImageOutputFormat,
   ProjectParams,
-  Sampler,
-  ForgeSampler,
-  ComfySampler,
-  Scheduler,
-  ForgeScheduler,
-  ComfyScheduler,
-  SupportedForgeSamplers,
-  SupportedForgeSchedulers,
-  SupportedComfySamplers,
-  SupportedComfySchedulers,
   VideoProjectParams,
   AudioFormat,
   VideoFormat,
@@ -52,13 +42,7 @@ export type {
   LogLevel,
   ProjectParams,
   ProjectStatus,
-  Sampler,
-  ForgeSampler,
-  ComfySampler,
   SupernetType,
-  Scheduler,
-  ForgeScheduler,
-  ComfyScheduler,
   TokenType,
   VideoFormat,
   VideoOutputFormat,
@@ -66,16 +50,7 @@ export type {
   VideoWorkflowType
 };
 
-export {
-  ApiError,
-  CurrentAccount,
-  Job,
-  Project,
-  SupportedComfySchedulers,
-  SupportedComfySamplers,
-  SupportedForgeSchedulers,
-  SupportedForgeSamplers
-};
+export { ApiError, CurrentAccount, Job, Project };
 
 export interface SogniClientConfig {
   /**