fix(video-generator): preserve saved settings and fix CI

Author: waleedlatif1

apps/sim/blocks/blocks/video_generator.ts

@@ -156,22 +156,22 @@ function selectedDirectModel(values?: Record<string, unknown>) {
 
 const directVideoFields = (
   [
-    ['directDuration', 'Duration (seconds)', 'durations'],
-    ['directAspectRatio', 'Aspect Ratio', 'aspectRatios'],
-    ['directResolution', 'Resolution', 'resolutions'],
+    ['duration', 'Duration (seconds)', 'durations'],
+    ['aspectRatio', 'Aspect Ratio', 'aspectRatios'],
+    ['resolution', 'Resolution', 'resolutions'],
     ['directGenerateAudio', 'Generate Audio', 'audio'],
-    ['directPromptOptimizer', 'Prompt Optimizer', 'promptOptimizer'],
+    ['promptOptimizer', 'Prompt Optimizer', 'promptOptimizer'],
   ] as const
 ).map(
   ([id, title, key]): SubBlockConfig => ({
     id,
     title,
-    type: 'dropdown',
-    value: () => FAL_MODEL_DEFAULT.id,
+    type: key === 'promptOptimizer' ? 'switch' : 'dropdown',
+    value: key === 'promptOptimizer' ? undefined : () => FAL_MODEL_DEFAULT.id,
     dependsOn: ['provider', 'model', 'visualReferenceInput', 'visualReferenceUpload'],
     condition: (values) => ({
-      field: 'model',
-      value: selectedDirectModel(values)?.settings?.[key] ? [String(values?.model)] : [],
+      field: 'provider',
+      value: selectedDirectModel(values)?.settings?.[key] ? [String(values?.provider)] : [],
     }),
     options: (params) => {
       if (!params) {
@@ -193,9 +193,8 @@ const directVideoFields = (
         ...choices
           .filter((value) => {
             if (model?.protocol !== 'minimax-v1') return true
-            if (key === 'durations' && params?.values.directResolution === '1080P')
-              return value === 6
-            if (key === 'resolutions' && Number(params?.values.directDuration) === 10)
+            if (key === 'durations' && params?.values.resolution === '1080P') return value === 6
+            if (key === 'resolutions' && Number(params?.values.duration) === 10)
               return value !== '1080P'
             return true
           })
@@ -1936,26 +1935,26 @@ export const VideoGeneratorV3Block: BlockConfig = {
             ? normalizeFileInput(params.visualReference, { single: true })
             : undefined
         const model = getDirectVideoModel(params.provider, params.model, Boolean(visualReference))
-        const setting = (legacy: string, current: string, supported: unknown) => {
+        const setting = (key: string, supported: unknown) => {
           if (!supported) return undefined
-          const value = params[current] ?? params[legacy]
+          const value = params[key]
           return value === FAL_MODEL_DEFAULT.id ? undefined : value
         }
-        const duration = setting('duration', 'directDuration', model?.settings?.durations)
+        const duration = setting('duration', model?.settings?.durations)
         return {
           provider: params.provider,
           model: params.model,
           apiKey: params.apiKey,
           prompt: params.prompt,
           visualReference,
           duration: duration ? Number(duration) : undefined,
-          aspectRatio: setting('aspectRatio', 'directAspectRatio', model?.settings?.aspectRatios),
-          resolution: setting('resolution', 'directResolution', model?.settings?.resolutions),
+          aspectRatio: setting('aspectRatio', model?.settings?.aspectRatios),
+          resolution: setting('resolution', model?.settings?.resolutions),
           generateAudio: parseOptionalBooleanInput(
-            setting('generateAudio', 'directGenerateAudio', model?.settings?.audio)
+            setting('directGenerateAudio', model?.settings?.audio)
           ),
           promptOptimizer: parseOptionalBooleanInput(
-            setting('promptOptimizer', 'directPromptOptimizer', model?.settings?.promptOptimizer)
+            setting('promptOptimizer', model?.settings?.promptOptimizer)
           ),
           endpoint: model?.protocol === 'minimax-v1' ? params.endpoint : undefined,
           cameraControl:
@@ -1970,14 +1969,14 @@ export const VideoGeneratorV3Block: BlockConfig = {
   },
   inputs: {
     ...VideoGeneratorV2Block.inputs,
-    directDuration: { type: 'number', description: 'Duration for the selected provider model' },
-    directAspectRatio: {
+    duration: { type: 'number', description: 'Duration for the selected provider model' },
+    aspectRatio: {
       type: 'string',
       description: 'Frame size or aspect ratio for the selected provider model',
     },
-    directResolution: { type: 'string', description: 'Resolution for the selected provider model' },
+    resolution: { type: 'string', description: 'Resolution for the selected provider model' },
     directGenerateAudio: { type: 'boolean', description: 'Generate audio when supported' },
-    directPromptOptimizer: {
+    promptOptimizer: {
       type: 'boolean',
       description: 'Enable prompt optimization when supported',
     },

apps/sim/lib/internal/video/client.test.ts

@@ -192,6 +192,48 @@ describe('Video provider client', () => {
     expect(submissions).toBe(1)
   })
 
+  it('reports a failed MiniMax job immediately instead of polling until timeout', async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(jsonResponse({ task_id: 'job' }))
+      .mockResolvedValue(jsonResponse({ status: 'Failed', failure_reason: 'Generation rejected' }))
+    vi.stubGlobal('fetch', fetchMock)
+    const result = generateVideo(
+      { provider: 'minimax', apiKey: 'key', prompt: 'A cinematic sunrise' },
+      { requestId: 'failed-minimax' }
+    )
+    const rejected = expect(result).rejects.toThrow('Generation rejected')
+    await Promise.all([rejected, vi.advanceTimersByTimeAsync(10_000)])
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+  })
+
+  it('keeps a saved MiniMax Pro preference compatible with a 720P-only model', async () => {
+    const fetchMock = vi
+      .fn<typeof fetch>()
+      .mockResolvedValueOnce(jsonResponse({ task_id: 'job' }))
+      .mockResolvedValueOnce(jsonResponse({ status: 'Success', file_id: 'file' }))
+      .mockResolvedValueOnce(
+        jsonResponse({ file: { download_url: 'https://cdn.example/video.mp4' } })
+      )
+    vi.stubGlobal('fetch', fetchMock)
+    const result = generateVideo(
+      {
+        provider: 'minimax',
+        model: 'T2V-01',
+        endpoint: 'pro',
+        apiKey: 'key',
+        prompt: 'A cinematic sunrise',
+      },
+      { requestId: 'legacy-pro' }
+    )
+    const completion = expect(result).resolves.toMatchObject({ buffer: Buffer.from('video') })
+    await Promise.all([completion, vi.advanceTimersByTimeAsync(5000)])
+    expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body))).toMatchObject({
+      model: 'T2V-01',
+      resolution: '720P',
+    })
+  })
+
   it('rejects malformed camera controls before submitting a paid Luma job', async () => {
     const fetchMock = vi.fn(() => {
       throw new Error('Unexpected paid request')

apps/sim/lib/internal/video/client.ts

@@ -289,6 +289,7 @@ async function generateWithDirectProvider(
         'canceled',
         'incomplete',
         'Fail',
+        'Failed',
       ].includes(status || '')
     ) {
       throw new Error(

apps/sim/lib/internal/video/direct-request.ts

@@ -39,6 +39,7 @@ export function buildDirectVideoRequest(input: VideoGenerationInput) {
     model.protocol === 'minimax-v1' &&
     !resolution &&
     input.endpoint === 'pro' &&
+    spec.resolutions?.includes('1080P') &&
     (input.duration ?? 6) === 6
   )
     resolution = '1080P'

apps/sim/lib/media/runway-video-models.json

@@ -691,7 +691,8 @@
       "durations": [2, 3, 4, 5, 6, 7, 8, 9, 10],
       "maxPromptLength": 1000,
       "defaults": {
-        "ratio": "1280:720"
+        "ratio": "1280:720",
+        "duration": 5
       }
     }
   }

apps/sim/lib/workflows/application/replace-workflow-state.test.ts

@@ -159,8 +159,8 @@ describe('replaceWorkflowState', () => {
   })
 
   it.each([
-    { provider: 'runway', model: 'gen4.5', directDuration: '5', directAspectRatio: '1280:720' },
-    { provider: 'minimax', model: 'MiniMax-H3', directResolution: '2K', directDuration: '7' },
+    { provider: 'runway', model: 'gen4.5', duration: '5', aspectRatio: '1280:720' },
+    { provider: 'minimax', model: 'MiniMax-H3', resolution: '2K', duration: '7' },
     { provider: 'falai', model: 'fal-ai/kandinsky5/text-to-video', falDuration: '5' },
   ])('saves configured $provider video workflows through the state API', async (settings) => {
     const block = {

apps/sim/lib/workflows/application/replace-workflow-state.ts

@@ -29,6 +29,10 @@ import {
 } from '@/lib/workflows/persistence/replace-normalized-state'
 import { loadWorkflowFromNormalizedTables } from '@/lib/workflows/persistence/utils'
 import { validateWorkflowState } from '@/lib/workflows/sanitization/validation'
+import {
+  buildSubBlockValues,
+  evaluateSubBlockCondition,
+} from '@/lib/workflows/subblocks/visibility'
 import {
   getToolBindingAuthoringSchema,
   validateToolBindingAuthoring,
@@ -140,6 +144,10 @@ export const replaceWorkflowState = defineAuthorizedWorkflowUseCase({
         const config = getBlock(block.type)
         if (!config) continue
         const fields = new Map(config.subBlocks.map((field) => [field.id, field]))
+        const values = buildSubBlockValues(block.subBlocks)
+        for (const field of config.subBlocks) {
+          if (evaluateSubBlockCondition(field.condition, values)) fields.set(field.id, field)
+        }
         for (const [fieldId, stored] of Object.entries(block.subBlocks ?? {})) {
           const field = fields.get(fieldId)
           if (!field) continue

apps/sim/scripts/test-organization-search-e2e.ts

@@ -1024,8 +1024,31 @@ try {
   await check('Search-only members recover legacy drafts without a remembered mode', () =>
     verifyLegacyDraft(undefined, 'assistant')
   )
-  await check('The UI completes without browser runtime errors', async () => {
-    assert.deepEqual(browserErrors, [])
+  await check('The UI completes without unexpected browser runtime errors', async () => {
+    await expect.poll(() => browserErrorEventCount).toBe(browserErrorCount)
+    const deniedRecoveries = browserErrorEvents.filter(
+      (event) =>
+        event.digest === 'NEXT_HTTP_ERROR_FALLBACK;404' &&
+        event.url === `${baseUrl.origin}${root}/search/chat/${deniedChatId}` &&
+        [
+          'Assistant history rejects a chat from another organization',
+          'A streamed denied chat remains navigable after hydration',
+        ].includes(event.stage)
+    )
+    const recoveryCount = deniedRecoveries.reduce((total, event) => total + event.count, 0)
+    assert.equal(browserErrorEventCount, recoveryCount, 'Unexpected browser error events')
+    assert.equal(browserErrorCount, recoveryCount, 'Unexpected browser runtime errors')
+    for (const sample of browserErrorSamples) {
+      const matchedCount = deniedRecoveries
+        .filter(
+          (event) =>
+            event.stage === sample.stage &&
+            event.url === sample.url &&
+            event.message === sample.message
+        )
+        .reduce((total, event) => total + event.count, 0)
+      assert.equal(sample.count, matchedCount, `Unexpected browser error: ${sample.message}`)
+    }
   })
 } catch (error) {
   logger.error('Organization Search E2E failed', { error: getErrorMessage(error) })

apps/sim/scripts/validate-runway-video-models.ts

@@ -95,9 +95,9 @@ for (const mode of ['text', 'image'] as const) {
         assert(validate(request.body), JSON.stringify(validate.errors))
         assert.equal(request.body.model, model.id)
         const wireKeys: Record<string, string> = {
-          directDuration: 'duration',
-          directAspectRatio: 'ratio',
-          directResolution: 'resolution',
+          duration: 'duration',
+          aspectRatio: 'ratio',
+          resolution: 'resolution',
           directGenerateAudio: 'audio',
         }
         for (const [field, value] of Object.entries(settings)) {
@@ -108,7 +108,10 @@ for (const mode of ['text', 'image'] as const) {
       }
       check({})
       for (const field of VideoGeneratorV3Block.subBlocks) {
-        if (!field.id.startsWith('direct') || !evaluateSubBlockCondition(field.condition, base))
+        if (
+          !['duration', 'aspectRatio', 'resolution', 'directGenerateAudio'].includes(field.id) ||
+          !evaluateSubBlockCondition(field.condition, base)
+        )
           continue
         const options =
           typeof field.options === 'function' ? field.options({ values: base }) : field.options

apps/sim/serializer/field-analysis.test.ts

@@ -14,6 +14,9 @@ vi.mock('@/blocks', () => ({
   getBlock: (type: string) => (type === 'svc' ? svcConfig.value : blocksMock.getBlock(type)),
 }))
 
+import { videoToolBodySchema } from '@/lib/api/contracts/tools/media/video'
+import { buildDirectVideoRequest } from '@/lib/internal/video/direct-request'
+import { VideoGeneratorV3Block } from '@/blocks/blocks/video_generator'
 import { collectBlockFieldIssues, extractBlockParams } from '@/serializer/index'
 import { getToolMetadata, getToolParams } from '@/tools/metadata'
 
@@ -135,6 +138,76 @@ describe('collectBlockFieldIssues', () => {
 })
 
 describe('extractBlockParams', () => {
+  it.each([
+    {
+      name: 'saved Luma duration, portrait ratio and resolution',
+      settings: {
+        provider: 'luma' as const,
+        model: 'ray-2',
+        duration: '9',
+        aspectRatio: '9:16',
+        resolution: '4k',
+      },
+      payload: { duration: '9s', aspect_ratio: '9:16', resolution: '4k' },
+    },
+    {
+      name: 'saved MiniMax duration and disabled prompt optimization',
+      settings: {
+        provider: 'minimax' as const,
+        duration: '10',
+        promptOptimizer: false,
+      },
+      payload: { duration: 10, prompt_optimizer: false },
+    },
+    {
+      name: 'MiniMax Pro preference on a 720P-only model',
+      settings: { provider: 'minimax' as const, model: 'T2V-01', endpoint: 'pro' },
+      payload: { model: 'T2V-01', resolution: '720P' },
+    },
+    {
+      name: 'Runway default duration with a reference image',
+      settings: {
+        provider: 'runway' as const,
+        visualReferenceUpload: [
+          {
+            id: 'reference',
+            name: 'image.png',
+            url: '/api/files/image.png',
+            key: 'workspace/reference.png',
+            size: 5,
+            type: 'image/png',
+          },
+        ],
+      },
+      payload: { model: 'gen4_turbo', duration: 5 },
+    },
+    {
+      name: 'current Google default without a retired duration',
+      settings: { provider: 'veo' as const },
+      payload: {
+        model: 'gemini-omni-1.1-flash',
+        response_format: { type: 'video', delivery: 'uri' },
+      },
+    },
+  ])('preserves $name through serialization into the provider request', ({ settings, payload }) => {
+    svcConfig.value = VideoGeneratorV3Block
+    const values = { apiKey: 'test-key', prompt: 'A cinematic sunrise', ...settings }
+    const params = extractBlockParams(
+      block({
+        type: 'svc',
+        subBlocks: Object.fromEntries(
+          Object.entries(values).map(([id, value]) => [id, { id, type: 'short-input', value }])
+        ),
+      })
+    )
+    const mapped = VideoGeneratorV3Block.tools.config?.params?.(params)
+    const request = buildDirectVideoRequest({
+      ...videoToolBodySchema.parse(mapped),
+      provider: settings.provider,
+    })
+    expect(request.body).toMatchObject(payload)
+  })
+
   it('resolves a canonical pair to its canonical id (advanced value wins when basic empty)', () => {
     svcConfig.value = config([
       {