added code for async processing

src/index.mts

@@ -1,7 +1,7 @@
 import { createReadStream, existsSync } from "node:fs"
 import path from "node:path"
 
-import { validate as uuidValidate } from "uuid"
+import { v4 as uuidv4, validate as uuidValidate } from "uuid"
 import express from "express"
 
 import { Video, VideoStatus, VideoAPIRequest, RenderRequest, RenderedScene } from "./types.mts"
@@ -21,7 +21,7 @@ import { initFolders } from "./initFolders.mts"
 import { sortVideosByYoungestFirst } from "./utils/sortVideosByYoungestFirst.mts"
 import { generateVideo } from "./production/generateVideo.mts"
 import { generateSeed } from "./utils/generateSeed.mts"
-import { renderScene } from "./production/renderScene.mts"
+import { getRenderedScene, renderScene } from "./production/renderScene.mts"
 
 initFolders()
 // to disable all processing (eg. to debug)
@@ -48,7 +48,9 @@ app.post("/render", async (req, res) => {
     return
   }
 
-  let result: RenderedScene = {
+  let response: RenderedScene = {
+    renderId: "",
+    status: "pending",
     assetUrl: "",
     maskBase64: "",
     error: "",
@@ -56,33 +58,84 @@ app.post("/render", async (req, res) => {
   }
   
   try {
-    result = await renderScene(request)
+    response = await renderScene(request)
   } catch (err) {
     // console.log("failed to render scene!")
-    result.error = `failed to render scene: ${err}`
+    response.error = `failed to render scene: ${err}`
   }
 
-  if (result.error === "already rendering") {
+  if (response.error === "already rendering") {
     console.log("server busy")
     res.status(200)
-    res.write(JSON.stringify({ url: "", error: result.error }))
+    res.write(JSON.stringify(response))
     res.end()
     return
-  } else if (result.error.length > 0) {
+  } else if (response.error.length > 0) {
     // console.log("server error")
     res.status(500)
-    res.write(JSON.stringify({ url: "", error: result.error }))
+    res.write(JSON.stringify(response))
     res.end()
     return
   } else {
     // console.log("all good")
     res.status(200)
-    res.write(JSON.stringify(result))
+    res.write(JSON.stringify(response))
+    res.end()
+    return
+  }
+})
+
+// a "fast track" pipeline
+app.get("/render/:renderId", async (req, res) => {
+
+  const renderId = `${req.params.renderId}`
+
+  if (!uuidValidate(renderId)) {
+    console.error("invalid render id")
+    res.status(400)
+    res.write(JSON.stringify({ error: `invalid render id` }))
+    res.end()
+    return
+  }
+
+  let response: RenderedScene = {
+    renderId: "",
+    status: "pending",
+    assetUrl: "",
+    error: "",
+    maskBase64: "",
+    segments: []
+  }
+
+  try {
+    response = await getRenderedScene(renderId)
+  } catch (err) {
+    // console.log("failed to render scene!")
+    response.error = `failed to render scene: ${err}`
+  }
+
+  if (response.error === "already rendering") {
+    console.log("server busy")
+    res.status(200)
+    res.write(JSON.stringify(response))
+    res.end()
+    return
+  } else if (response.error.length > 0) {
+    // console.log("server error")
+    res.status(500)
+    res.write(JSON.stringify(response))
+    res.end()
+    return
+  } else {
+    // console.log("all good")
+    res.status(200)
+    res.write(JSON.stringify(response))
     res.end()
     return
   }
 })
 
+
 // a "fast track" pipeline
 /*
 app.post("/segment", async (req, res) => {

src/production/renderImage.mts

@@ -0,0 +1,54 @@
+import { RenderedScene, RenderRequest } from "../types.mts"
+import { generateImageSDXLAsBase64 } from "../utils/generateImageSDXL.mts"
+import { generateImageSDXL360AsBase64 } from "../utils/generateImageSDXL360.mts"
+import { generateSeed } from "../utils/generateSeed.mts"
+
+export async function renderImage(
+  request: RenderRequest,
+  response: RenderedScene,
+): Promise<RenderedScene> {
+
+  const isSpherical = request.projection === 'spherical'
+
+  const generateImageAsBase64 = isSpherical
+    ? generateImageSDXL360AsBase64
+    : generateImageSDXLAsBase64
+
+  console.log(`going to generate an image using ${request.projection || "default (cartesian)"} projection`)
+  
+  const params = {
+    positivePrompt: request.prompt,
+    seed: request.seed,
+    nbSteps: request.nbSteps,
+    width: request.width,
+    request: request.height
+  }
+
+  console.log(`calling generateImageAsBase64 with: `, JSON.stringify(params, null, 2))
+
+
+  // first we generate a quick low quality version
+  try {
+    response.assetUrl = await generateImageAsBase64(params)
+    console.log("successful generation!", response.assetUrl.slice(0, 30))
+    if (!response.assetUrl?.length) {
+      throw new Error(`the generated image is empty`)
+    }
+  } catch (err) {
+    console.error(`failed to render.. but let's try again!`)
+    try {
+      response.assetUrl = await generateImageAsBase64(params)
+      console.log("successful generation!", response.assetUrl.slice(0, 30))
+      if (!response.assetUrl?.length) {
+        throw new Error(`the generated image is empty`)
+      }
+    } catch (err) {
+      console.error(`failed to generate the image, although ${err}`)
+      response.error = `failed to render scene: ${err}`
+      response.status = "error"
+      response.assetUrl = ""
+    }
+  }
+
+  return response
+}

src/production/{renderStaticScene.mts → renderImageSegmentation.mts}

@@ -3,63 +3,17 @@ import path from "node:path"
 import { v4 as uuidv4 } from "uuid"
 import tmpDir from "temp-dir"
 
-import { ImageSegment, RenderedScene, RenderingJob, RenderRequest } from "../types.mts"
+import { RenderedScene, RenderRequest } from "../types.mts"
 import { segmentImage } from "../utils/segmentImage.mts"
-import { generateImageSDXLAsBase64 } from "../utils/generateImageSDXL.mts"
 import { writeBase64ToFile } from "../utils/writeBase64ToFile.mts"
 
 
-const pendingJobs: RenderingJob[] = []
+export async function renderImageSegmentation(
+  request: RenderRequest,
+  response: RenderedScene,
+): Promise<RenderedScene> {
 
-export async function renderStaticScene(scene: RenderRequest): Promise<RenderedScene> {
-
-  let imageBase64 = ""
-  let error = ""
-
-  const width = 1024
-  const height = 512
-
-  const params = {
-    positivePrompt: scene.prompt,
-    seed: scene.seed || undefined,
-    nbSteps: scene.nbSteps || undefined,
-    width,
-    height
-  }
-  console.log(`calling generateImageSDXLAsBase64 with: `, JSON.stringify(params, null, 2))
-
-  try {
-    imageBase64 = await generateImageSDXLAsBase64(params)
-    console.log("successful generation!", imageBase64.slice(0, 30))
-    error = ""
-    if (!imageBase64?.length) {
-      throw new Error(`the generated image is empty`)
-    }
-  } catch (err) {
-    console.error(`failed to render.. but let's try again!`)
-    try {
-      imageBase64 = await generateImageSDXLAsBase64(params)
-      console.log("successful generation!", imageBase64.slice(0, 30))
-      error = ""
-      if (!imageBase64?.length) {
-        throw new Error(`the generated image is empty`)
-      }
-    } catch (err) {
-      console.error(`failed to generate the image, although ${err}`)
-      error = `failed to render scene: ${err}`
-      return {
-        assetUrl: imageBase64,
-        error,
-        maskBase64: "",
-        segments: []
-      } as RenderedScene
-    }
-  }
-
-  const actionnables = Array.isArray(scene.actionnables) ? scene.actionnables : []
-
-  let mask = ""
-  let segments: ImageSegment[] = []
+  const actionnables = Array.isArray(request.actionnables) ? request.actionnables : []
 
   if (actionnables.length > 0) {
     console.log("we have some actionnables:", actionnables)
@@ -68,35 +22,41 @@ export async function renderStaticScene(scene: RenderRequest): Promise<RenderedS
     const tmpImageFilePath = path.join(tmpDir, `${uuidv4()}.png`)
 
     // console.log("beginning:", imageBase64.slice(0, 100))
-    await writeBase64ToFile(imageBase64, tmpImageFilePath)
+    await writeBase64ToFile(response.assetUrl, tmpImageFilePath)
     console.log("wrote the image to ", tmpImageFilePath)
   
     if (!tmpImageFilePath) {
       console.error("failed to get the image")
-      error = "failed to segment the image"
+      response.error = "failed to segment the image"
+      response.status = "error"
     } else {
       console.log("got the first frame! segmenting..")
       try {
-        const result = await segmentImage(tmpImageFilePath, actionnables, width, height)
-        mask = result.pngInBase64
-        segments = result.segments
-        console.log(`it worked the first time! got ${segments.length} segments`)
+        const result = await segmentImage(tmpImageFilePath, actionnables, request.width, request.height)
+        response.maskBase64 = result.pngInBase64
+        response.segments = result.segments
+  
+        console.log(`it worked the first time! got ${response.segments.length} segments`)
       } catch (err) {
         console.log("this takes too long :/ trying another server..")
         try {
-          const result = await segmentImage(tmpImageFilePath, actionnables, width, height)
-          mask = result.pngInBase64
-          segments = result.segments
-          console.log(`it worked the second time! got ${segments.length} segments`)
+          const result = await segmentImage(tmpImageFilePath, actionnables, request.width, request.height)
+          response.maskBase64 = result.pngInBase64
+          response.segments = result.segments
+         
+          console.log(`it worked the second time! got ${response.segments.length} segments`)
         } catch (err) {
           console.log("trying one last time, on a 3rd server..")
           try {
-            const result = await segmentImage(tmpImageFilePath, actionnables, width, height)
-            mask = result.pngInBase64
-            segments = result.segments
-            console.log(`it worked the third time! got ${segments.length} segments`)
+            const result = await segmentImage(tmpImageFilePath, actionnables, request.width, request.height)
+            response.maskBase64 = result.pngInBase64
+            response.segments = result.segments
+        
+            console.log(`it worked the third time! got ${response.segments.length} segments`)
           } catch (err) {
             console.log("yeah, all servers are busy it seems.. aborting")
+            response.error = "all servers are busy"
+            response.status = "error"
           }
         }
       }
@@ -105,12 +65,5 @@ export async function renderStaticScene(scene: RenderRequest): Promise<RenderedS
     console.log("no actionnables: just returning the image, then")
   }
 
-  error = ""
-
-  return {
-    assetUrl: imageBase64,
-    error,
-    maskBase64: mask,
-    segments
-  } as RenderedScene
+  return response
 }

src/production/renderPipeline.mts

@@ -0,0 +1,46 @@
+
+import { RenderedScene, RenderRequest } from "../types.mts"
+
+import { renderImage } from "./renderImage.mts"
+import { renderVideo } from "./renderVideo.mts"
+import { renderImageSegmentation } from "./renderImageSegmentation.mts"
+import { renderVideoSegmentation } from "./renderVideoSegmentation.mts"
+
+export async function renderPipeline(request: RenderRequest, response: RenderedScene) {
+  const isVideo = request?.nbFrames > 1
+
+  const renderContent = isVideo ? renderVideo : renderImage
+  const renderSegmentation  = isVideo ? renderVideoSegmentation : renderImageSegmentation 
+
+  if (isVideo) {
+    console.log(`rendering a video..`)
+  } else {
+    console.log(`rendering an image..`)
+  }
+  await renderContent(request, response)
+  await renderSegmentation(request, response)
+
+  /*
+  this is the optimized pipeline
+  However, right now it doesn't work because for some reason,
+  asking to generate the same seed + prompt on different nb of steps
+  doesn't generate the same image!
+
+  // first we need to wait for the low quality pre-render
+  await renderContent({
+    ...request,
+
+    // we are a bit more aggressive with the quality of the video preview
+    nbSteps: isVideo ? 8 : 16
+  }, response)
+
+  // then we can run both the segmentation and the high-res render at the same time
+  await Promise.all([
+    renderSegmentation(request, response),
+    renderContent(request, response)
+  ])
+  */
+
+  response.status = "completed"
+  response.error = ""
+}

src/production/renderScene.mts

@@ -1,13 +1,62 @@
+import { v4 as uuidv4 } from "uuid"
+
 import { RenderedScene, RenderRequest } from "../types.mts"
-import { renderStaticScene } from "./renderStaticScene.mts"
-import { renderVideoScene } from "./renderVideoScene.mts"
+import { generateSeed } from "../utils/generateSeed.mts"
+import { getValidNumber } from "../utils/getValidNumber.mts"
+import { renderPipeline } from "./renderPipeline.mts"
+
+const cache: Record<string, RenderedScene> = {}
+const cacheQueue: string[] = []
+const maxCacheSize = 1000
+
+export async function renderScene(request: RenderRequest): Promise<RenderedScene> {
+  // const key = getCacheKey(scene)
+  const renderId = uuidv4()
+
+  request.nbFrames = getValidNumber(request.nbFrames, 1, 24, 16)
 
-export async function renderScene(scene: RenderRequest): Promise<RenderedScene> {
-  if (scene?.nbFrames === 1) {
-    console.log(`calling renderStaticScene`)
-    return renderStaticScene(scene)
+  const isVideo = request?.nbFrames === 1
+
+  // important: we need a consistent seed for our multiple rendering passes
+  request.seed = getValidNumber(request.seed, 0, 2147483647, generateSeed())
+  request.nbSteps = getValidNumber(request.nbSteps, 5, 50, 10)
+
+  if (isVideo) {
+    request.width = getValidNumber(request.width, 256, 1024, 1024)
+    request.height = getValidNumber(request.width, 256, 1024, 512)
   } else {
-    console.log(`calling renderVideoScene`)
-    return renderVideoScene(scene)
+    request.width = getValidNumber(request.width, 256, 1280, 576)
+    request.height = getValidNumber(request.width, 256, 720, 320)
+  }
+
+  const response: RenderedScene = {
+    renderId,
+    status: "pending",
+    assetUrl: "",
+    error: "",
+    maskBase64: "",
+    segments: []
+  }
+
+  cache[renderId] = response
+  cacheQueue.push(renderId)
+  if (cacheQueue.length > maxCacheSize) {
+    const toRemove = cacheQueue.shift()
+    delete cache[toRemove]
+  }
+
+  // this is a fire-and-forget asynchronous pipeline:
+  // we start it, but we do not await for the response
+  renderPipeline(request, response)
+
+  console.log("renderScene: yielding the scene", response)
+  return response
+}
+
+export async function getRenderedScene(renderId: string): Promise<RenderedScene> {
+  const rendered = cache[renderId]
+  if (!rendered) {
+    throw new Error(`couldn't find any rendered scene with renderId ${renderId}`)
   }
+  return cache[renderId]
 }

src/production/renderVideo.mts

@@ -0,0 +1,41 @@
+import { RenderedScene, RenderRequest } from "../types.mts"
+import { generateVideo } from "./generateVideo.mts"
+
+export async function renderVideo(
+  request: RenderRequest,
+  response: RenderedScene
+): Promise<RenderedScene> {
+
+  const params = {
+    seed: request.seed,
+    nbFrames: request.nbFrames,
+    nbSteps: request.nbSteps,
+  }
+
+  try {
+    response.assetUrl = await generateVideo(request.prompt, params)
+    // console.log("successfull generation")
+
+    if (!response.assetUrl?.length) {
+      throw new Error(`url for the generated video is empty`)
+    }
+  } catch (err) {
+    console.error(`failed to render the video scene.. but let's try again!`)
+
+    try {
+      response.assetUrl = await generateVideo(request.prompt, params)
+      // console.log("successfull generation")
+
+      if (!response.assetUrl?.length) {
+        throw new Error(`url for the generated video is empty`)
+      }
+      
+    } catch (err) {
+      console.error(`it failed the video for second time ${err}`)
+      response.error = `failed to render video scene: ${err}`
+      response.status = "error"
+    }
+  }
+
+  return response
+}

src/production/{renderVideoScene.mts → renderVideoSegmentation.mts}

@@ -1,76 +1,36 @@
 import { v4 as uuidv4 } from "uuid"
 
-import { ImageSegment, RenderedScene, RenderRequest } from "../types.mts"
+import { RenderedScene, RenderRequest } from "../types.mts"
 import { downloadFileToTmp } from "../utils/downloadFileToTmp.mts"
-import { generateSeed } from "../utils/generateSeed.mts"
-import { getValidNumber } from "../utils/getValidNumber.mts"
-import { generateVideo } from "./generateVideo.mts"
 import { getFirstVideoFrame } from "../utils/getFirstVideoFrame.mts"
 import { segmentImage } from "../utils/segmentImage.mts"
 
-export async function renderVideoScene(scene: RenderRequest): Promise<RenderedScene> {
-
-  let url = ""
-  let error = ""
-
-  const width = 576
-  const height = 320
-
-  const params = {
-    seed: getValidNumber(scene.seed, 0, 2147483647, generateSeed()),
-    nbFrames: getValidNumber(scene.nbFrames, 8, 24, 16), // 2 seconds by default
-    nbSteps: getValidNumber(scene.nbSteps, 1, 50, 10), // use 10 by default to go fast, but not too sloppy
-  }
-
-  try {
-    url = await generateVideo(scene.prompt, params)
-    // console.log("successfull generation")
-    error = ""
-    if (!url?.length) {
-      throw new Error(`url for the generated image is empty`)
-    }
-  } catch (err) {
-    console.error(`failed to render the scene.. but let's try again!`)
-
-    try {
-      url = await generateVideo(scene.prompt, params)
-      // console.log("successfull generation")
-      error = ""
-
-      if (!url?.length) {
-        throw new Error(`url for the generated image is empty`)
-      }
-      
-    } catch (err) {
-      console.error(`it failed the second time ${err}`)
-      error = `failed to render scene: ${err}`
-    }
-  }
-
-
-  // TODO add segmentation here
-  const actionnables = Array.isArray(scene.actionnables) ? scene.actionnables : []
-
-  let mask = ""
-  let segments: ImageSegment[] = []
+export async function renderVideoSegmentation(
+  request: RenderRequest,
+  response: RenderedScene
+): Promise<RenderedScene> {
+  
+  const actionnables = Array.isArray(request.actionnables) ? request.actionnables : []
 
   if (actionnables.length > 0) {
     console.log("we have some actionnables:", actionnables)
-    if (scene.segmentation === "firstframe") {
+    if (request.segmentation === "firstframe") {
       console.log("going to grab the first frame")
-      const tmpVideoFilePath = await downloadFileToTmp(url, `${uuidv4()}`)
+      const tmpVideoFilePath = await downloadFileToTmp(response.assetUrl, `${uuidv4()}`)
       console.log("downloaded the first frame to ", tmpVideoFilePath)
       const firstFrameFilePath = await getFirstVideoFrame(tmpVideoFilePath)
       console.log("downloaded the first frame to ", firstFrameFilePath)
       
       if (!firstFrameFilePath) {
         console.error("failed to get the image")
-        error = "failed to segment the image"
+        response.error = "failed to segment the image"
+        response.status = "error"
       } else {
         console.log("got the first frame! segmenting..")
-        const result = await segmentImage(firstFrameFilePath, actionnables, width, height)
-        mask = result.pngInBase64
-        segments = result.segments
+        const result = await segmentImage(firstFrameFilePath, actionnables, request.width, request.height)
+        response.maskBase64 = result.pngInBase64
+        response.segments = result.segments
+
         // console.log("success!", {  segments })
       }
       /*
@@ -88,12 +48,5 @@ export async function renderVideoScene(scene: RenderRequest): Promise<RenderedSc
     }
   }
 
-  error = ""
-
-  return {
-    assetUrl: url,
-    error,
-    maskBase64: mask,
-    segments
-  } as RenderedScene
+  return response
 }

src/types.mts

@@ -269,6 +269,8 @@ export type Video = VideoSequence & {
   shots: VideoShot[]
 }
 
+export type ProjectionMode = 'cartesian' | 'spherical'
+
 export interface RenderRequest {
   prompt: string
 
@@ -292,6 +294,11 @@ export interface RenderRequest {
   nbSteps: number // min: 1, max: 50
 
   seed: number
+
+  width: number
+  height: number
+
+  projection: ProjectionMode
 }
 
 export interface ImageSegmentationRequest {
@@ -307,7 +314,11 @@ export interface ImageSegment {
   score: number 
 }
 
+export type RenderedSceneStatus = 'pending' | 'completed' | 'error'
+
 export interface RenderedScene {
+  renderId: string
+  status: RenderedSceneStatus
   assetUrl: string 
   error: string
   maskBase64: string

src/utils/generateImageSDXL.mts

@@ -27,6 +27,7 @@ export async function generateImageSDXLAsBase64(options: {
   const width = getValidNumber(options?.width, 256, 1024, 512)
   const height = getValidNumber(options?.height, 256, 1024, 512)
   const nbSteps = getValidNumber(options?.nbSteps, 5, 100, 20)
+  console.log("SEED:", seed)
 
   const instance = instances.shift()
   instances.push(instance)
@@ -68,8 +69,8 @@ export async function generateImageSDXLAsBase64(options: {
     seed, // number (numeric value between 0 and 2147483647) in 'Seed' Slider component		
     width, // number (numeric value between 256 and 1024) in 'Width' Slider component		
     height, // number (numeric value between 256 and 1024) in 'Height' Slider component		
-    7, // number (numeric value between 1 and 20) in 'Guidance scale for base' Slider component		
-    7, // number (numeric value between 1 and 20) in 'Guidance scale for refiner' Slider component		
+    8, // number (numeric value between 1 and 20) in 'Guidance scale for base' Slider component		
+    8, // number (numeric value between 1 and 20) in 'Guidance scale for refiner' Slider component		
     nbSteps, // number (numeric value between 10 and 100) in 'Number of inference steps for base' Slider component		
     nbSteps, // number (numeric value between 10 and 100) in 'Number of inference steps for refiner' Slider component		
     true, // boolean  in 'Apply refiner' Checkbox component

src/utils/generateImageSDXL360.mts

@@ -0,0 +1,81 @@
+import { client } from "@gradio/client"
+
+import { generateSeed } from "../utils/generateSeed.mts"
+import { getValidNumber } from "./getValidNumber.mts"
+
+// we don't use replicas yet, because it ain't easy to get their hostname
+const instances: string[] = [
+  `${process.env.VC_SDXL_360_SPACE_API_URL_1 || ""}`,
+ //  `${process.env.VC_SDXL_SPACE_API_URL_2 || ""}`,
+].filter(instance => instance?.length > 0)
+
+export async function generateImageSDXL360AsBase64(options: {
+  positivePrompt: string;
+  negativePrompt?: string;
+  seed?: number;
+  width?: number;
+  height?: number;
+  nbSteps?: number;
+}) {
+
+  const positivePrompt = options?.positivePrompt || ""
+  if (!positivePrompt) {
+    throw new Error("missing prompt")
+  }
+  const negativePrompt = options?.negativePrompt || ""
+  const seed = getValidNumber(options?.seed, 0, 2147483647, generateSeed())
+  const width = getValidNumber(options?.width, 256, 1024, 512)
+  const height = getValidNumber(options?.height, 256, 1024, 512)
+  const nbSteps = getValidNumber(options?.nbSteps, 5, 100, 20)
+  console.log("SEED FOR 360:", seed)
+
+  const instance = instances.shift()
+  instances.push(instance)
+
+  const positive = [
+    "360 view",
+    positivePrompt,
+    "beautiful",
+    "intricate details",
+    "award winning",
+    "high resolution"
+  ].filter(word => word)
+  .join(", ")
+
+  const negative =  [
+    negativePrompt,
+    "watermark",
+    "copyright",
+    "blurry",
+    // "artificial",
+    // "cropped",
+    "low quality",
+    "ugly"
+  ].filter(word => word)
+  .join(", ")
+
+  const api = await client(instance, {
+    hf_token: `${process.env.VC_HF_API_TOKEN}` as any
+  })
+
+  
+  const rawResponse = (await api.predict("/run", [		
+    positive, // string  in 'Prompt' Textbox component		
+    negative, // string  in 'Negative prompt' Textbox component		
+    positive, // string  in 'Prompt 2' Textbox component		
+    negative, // string  in 'Negative prompt 2' Textbox component		
+    true, // boolean  in 'Use negative prompt' Checkbox component		
+    false, // boolean  in 'Use prompt 2' Checkbox component		
+    false, // boolean  in 'Use negative prompt 2' Checkbox component		
+    seed, // number (numeric value between 0 and 2147483647) in 'Seed' Slider component		
+    width, // number (numeric value between 256 and 1024) in 'Width' Slider component		
+    height, // number (numeric value between 256 and 1024) in 'Height' Slider component		
+    8, // number (numeric value between 1 and 20) in 'Guidance scale for base' Slider component		
+    8, // number (numeric value between 1 and 20) in 'Guidance scale for refiner' Slider component		
+    nbSteps, // number (numeric value between 10 and 100) in 'Number of inference steps for base' Slider component		
+    nbSteps, // number (numeric value between 10 and 100) in 'Number of inference steps for refiner' Slider component		
+    true, // boolean  in 'Apply refiner' Checkbox component
+  ])) as any
+    
+  return rawResponse?.data?.[0] as string
+}