fix(video-generator): preserve Agent audio and model prompt limits

Author: waleedlatif1

apps/sim/blocks/blocks/video_generator.ts

@@ -1935,9 +1935,9 @@ export const VideoGeneratorV3Block: BlockConfig = {
             ? normalizeFileInput(params.visualReference, { single: true })
             : undefined
         const model = getDirectVideoModel(params.provider, params.model, Boolean(visualReference))
-        const setting = (key: string, supported: unknown) => {
+        const setting = (key: string, supported: unknown, fallbackKey?: string) => {
           if (!supported) return undefined
-          const value = params[key]
+          const value = params[key] ?? (fallbackKey ? params[fallbackKey] : undefined)
           return value === FAL_MODEL_DEFAULT.id ? undefined : value
         }
         const duration = setting('duration', model?.settings?.durations)
@@ -1951,7 +1951,7 @@ export const VideoGeneratorV3Block: BlockConfig = {
           aspectRatio: setting('aspectRatio', model?.settings?.aspectRatios),
           resolution: setting('resolution', model?.settings?.resolutions),
           generateAudio: parseOptionalBooleanInput(
-            setting('directGenerateAudio', model?.settings?.audio)
+            setting('directGenerateAudio', model?.settings?.audio, 'generateAudio')
           ),
           promptOptimizer: parseOptionalBooleanInput(
             setting('promptOptimizer', model?.settings?.promptOptimizer)

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

@@ -7,8 +7,11 @@ import {
   inputValidationMock,
   inputValidationMockFns,
 } from '@sim/testing/mocks/input-validation.mock'
+import { storageServiceMockFns } from '@sim/testing/mocks/storage-service.mock'
+import { uploadsMock } from '@sim/testing/mocks/uploads.mock'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
+vi.mock('@/lib/uploads', () => uploadsMock)
 vi.mock('@/lib/core/execution-limits', () => executionLimitsMock)
 vi.mock('@/lib/core/security/input-validation.server', () => inputValidationMock)
 
@@ -34,6 +37,40 @@ describe('Video provider client', () => {
     vi.useRealTimers()
   })
 
+  it.each([
+    { model: 'gen4.5', limit: 1000 },
+    { model: 'klingO3_4k', limit: 2500 },
+    { model: 'kling_4', limit: 26000 },
+  ])(
+    'accepts the published prompt limit for $model and rejects overflow before submission',
+    async ({ model, limit }) => {
+      const mockFetch = vi
+        .fn<typeof fetch>()
+        .mockResolvedValueOnce(jsonResponse({ id: 'job' }))
+        .mockResolvedValueOnce(
+          jsonResponse({ status: 'SUCCEEDED', output: ['data:video/mp4;base64,dmlkZW8='] })
+        )
+      vi.stubGlobal('fetch', mockFetch)
+      storageServiceMockFns.mockUploadFile.mockResolvedValue({
+        path: '/api/files/video.mp4',
+        size: 5,
+      })
+      const input = { provider: 'runway' as const, model, apiKey: 'key', prompt: 'a'.repeat(limit) }
+      const context = { requestId: 'prompt-boundary', userId: 'user', headers: new Headers() }
+      const completion = expect(executeVideoOperation(input, context)).resolves.toMatchObject({
+        model,
+      })
+      await Promise.all([completion, vi.advanceTimersByTimeAsync(5000)])
+      expect(JSON.parse(String(mockFetch.mock.calls[0]?.[1]?.body)).promptText).toBe(input.prompt)
+
+      mockFetch.mockClear()
+      await expect(
+        executeVideoOperation({ ...input, prompt: `${input.prompt}a` }, context)
+      ).rejects.toThrow(`Prompt must be between 3 and ${limit} characters`)
+      expect(mockFetch).not.toHaveBeenCalled()
+    }
+  )
+
   it.each([
     {
       provider: 'luma' as const,

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

@@ -83,10 +83,11 @@ async function waitForProvider(context: VideoGenerationContext): Promise<void> {
 }
 
 export function getVideoInputValidationError(input: VideoGenerationInput): string | undefined {
-  if (input.prompt.length < 3 || input.prompt.length > 2000) {
-    return 'Prompt must be between 3 and 2000 characters'
+  if (input.provider === 'falai') {
+    if (input.prompt.length < 3 || input.prompt.length > 2000)
+      return 'Prompt must be between 3 and 2000 characters'
+    return getFalAIValidationError(input)
   }
-  if (input.provider === 'falai') return getFalAIValidationError(input)
   try {
     buildDirectVideoRequest(input)
   } catch (error) {

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

@@ -15,7 +15,7 @@ export function buildDirectVideoRequest(input: VideoGenerationInput) {
     throw new Error(
       `${model.label} ${input.visualReference ? 'does not accept a reference image' : 'requires a reference image'}`
     )
-  const maxLength = Math.min(2000, spec.maxPromptLength ?? 2000)
+  const maxLength = spec.maxPromptLength ?? 2000
   if (input.prompt.length < 3 || input.prompt.length > maxLength)
     throw new Error(`Prompt must be between 3 and ${maxLength} characters for ${model.label}`)
   let aspectRatio = input.aspectRatio

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

@@ -7,6 +7,7 @@ import assert from 'node:assert/strict'
 import { readFile, writeFile } from 'node:fs/promises'
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
+import { isRecordLike } from '@sim/utils/object'
 import Ajv from 'ajv/dist/2020'
 import { videoToolBodySchema } from '@/lib/api/contracts/tools/media/video'
 import { readResponseJsonWithLimit } from '@/lib/core/utils/stream-limits'
@@ -95,6 +96,7 @@ 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> = {
+          prompt: 'promptText',
           duration: 'duration',
           aspectRatio: 'ratio',
           resolution: 'resolution',
@@ -107,6 +109,14 @@ for (const mode of ['text', 'image'] as const) {
         requests++
       }
       check({})
+      const promptSchema = schema.properties.promptText
+      assert(isRecordLike(promptSchema) && typeof promptSchema.maxLength === 'number')
+      const maxPromptLength = promptSchema.maxLength
+      check({ prompt: 'a'.repeat(maxPromptLength) })
+      assert.throws(
+        () => buildDirectVideoRequest({ ...base, prompt: 'a'.repeat(maxPromptLength + 1) }),
+        /Prompt must be between/
+      )
       for (const field of VideoGeneratorV3Block.subBlocks) {
         if (
           !['duration', 'aspectRatio', 'resolution', 'directGenerateAudio'].includes(field.id) ||

apps/sim/tools/index.test.ts

@@ -57,13 +57,15 @@ import {
 } from '@sim/testing'
 import { DrizzleQueryError } from 'drizzle-orm/errors'
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { videoToolBodySchema } from '@/lib/api/contracts/tools/media/video'
 import { withAssistantActionExecution } from '@/lib/assistant-actions/execution-scope'
 import type { BillingAttributionSnapshot } from '@/lib/billing/core/attribution'
 import type { EnvironmentResolutionSnapshot } from '@/lib/environment/utils'
 import { executeBitbucketTool } from '@/lib/internal/bitbucket/execute-tool'
 import { createInternalToolFileResult } from '@/lib/internal/tool-operations/file-result'
 import type { InternalToolOperationCall } from '@/lib/internal/tool-operations/types'
 import { executeVantaTool } from '@/lib/internal/vanta/execute-tool'
+import { buildDirectVideoRequest } from '@/lib/internal/video/direct-request'
 import { projectToolResultForCopilot } from '@/lib/mothership/request/tools/resolved-secret-result'
 import { VideoGeneratorV3Block } from '@/blocks/blocks/video_generator'
 import {
@@ -5115,6 +5117,34 @@ describe('File Parameter Normalization', () => {
     }
   )
 
+  it.each([
+    { configured: undefined, requested: false, expected: false },
+    { configured: undefined, requested: true, expected: true },
+    { configured: false, requested: true, expected: false },
+  ])('preserves Agent audio choices and configured overrides ($expected)', async (testCase) => {
+    const providerTool = await transformBlockTool(
+      {
+        type: 'video_generator_v3',
+        params: {
+          provider: 'runway',
+          apiKey: 'test-runway-key',
+          directGenerateAudio: testCase.configured,
+        },
+      },
+      { getAllBlocks: () => [VideoGeneratorV3Block], getTool: () => runwayVideoTool }
+    )
+    if (!providerTool) throw new Error('Video tool was not exposed to the Agent')
+    const prepared = prepareToolExecution(
+      providerTool,
+      { model: 'veo3.1', prompt: 'Animate the boat', generateAudio: testCase.requested },
+      {},
+      'call-video-audio'
+    )
+    const input = videoToolBodySchema.parse(prepared.toolParams)
+    const request = buildDirectVideoRequest({ ...input, provider: 'runway' })
+    expect(request.body.audio).toBe(testCase.expected)
+  })
+
   it('resolves canonical file IDs for single-file params during copilot execution', async () => {
     mockResolveWorkspaceFileReference.mockResolvedValue({
       id: 'wf_123',