@transloadit/node 4.1.3

package/src/alphalib/types/robots/ai-chat.ts

@@ -0,0 +1,278 @@
+import { z } from 'zod'
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
+
+// We duplicate coreMessageSchema (and its related types) from structuredAiVercel.ts here
+// so that we do not need to distribute structuredAiVercel.ts to for instance
+// the node-sdk, which does rely on this ai-chat file to determine
+// support Robot parameters.
+
+// Define JSONValue schema for proper type matching with AI SDK
+const jsonValueSchema: z.ZodType = z.lazy(() =>
+  z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.record(jsonValueSchema),
+  ]),
+)
+
+// Define provider metadata schema to match the AI SDK v5
+const providerMetadataSchema = z.record(z.record(jsonValueSchema)).optional()
+
+const textPartSchema = z.object({
+  type: z.literal('text'),
+  text: z.string(),
+  experimental_providerMetadata: providerMetadataSchema,
+})
+const imagePartSchema = z.object({
+  type: z.literal('image'),
+  image: z.union([
+    z.string(),
+    z.instanceof(Uint8Array),
+    z.instanceof(ArrayBuffer),
+    // Note: Buffer is not included here since it's Node.js-only and this code runs in browsers.
+    // Node.js Buffer extends Uint8Array, so Uint8Array validation handles Buffer values too.
+    z.instanceof(URL),
+  ]),
+  mimeType: z.string().optional(),
+  experimental_providerMetadata: providerMetadataSchema,
+})
+const filePartSchema = z.object({
+  type: z.literal('file'),
+  data: z.union([
+    z.string(),
+    z.instanceof(Uint8Array),
+    z.instanceof(ArrayBuffer),
+    // Note: Buffer is not included here since it's Node.js-only and this code runs in browsers.
+    // Node.js Buffer extends Uint8Array, so Uint8Array validation handles Buffer values too.
+    z.instanceof(URL),
+  ]),
+  mediaType: z.string(),
+  experimental_providerMetadata: providerMetadataSchema,
+})
+const toolCallPartSchema = z.object({
+  type: z.literal('tool-call'),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  args: z.record(jsonValueSchema),
+  experimental_providerMetadata: providerMetadataSchema,
+})
+const toolResultPartSchema = z.object({
+  type: z.literal('tool-result'),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  result: z.unknown(),
+  experimental_content: z
+    .array(
+      z.union([
+        z.object({
+          type: z.literal('text'),
+          text: z.string(),
+        }),
+        z.object({
+          type: z.literal('image'),
+          data: z.string(),
+          mimeType: z.string().optional(),
+        }),
+      ]),
+    )
+    .optional(),
+  isError: z.boolean().optional(),
+  experimental_providerMetadata: providerMetadataSchema,
+})
+const coreSystemMessageSchema = z.object({
+  role: z.literal('system'),
+  content: z.string(),
+  experimental_providerMetadata: providerMetadataSchema,
+})
+const coreUserMessageSchema = z.object({
+  role: z.literal('user'),
+  content: z.union([
+    z.string(),
+    z.array(z.union([textPartSchema, imagePartSchema, filePartSchema])),
+  ]),
+  experimental_providerMetadata: providerMetadataSchema,
+})
+const coreAssistantMessageSchema = z.object({
+  role: z.literal('assistant'),
+  content: z.union([z.string(), z.array(z.union([textPartSchema, toolCallPartSchema]))]),
+  experimental_providerMetadata: providerMetadataSchema,
+})
+const coreToolMessageSchema = z.object({
+  role: z.literal('tool'),
+  content: z.array(toolResultPartSchema),
+  experimental_providerMetadata: providerMetadataSchema,
+})
+const coreMessageSchema = z.discriminatedUnion('role', [
+  coreSystemMessageSchema,
+  coreUserMessageSchema,
+  coreAssistantMessageSchema,
+  coreToolMessageSchema,
+])
+
+export const meta: RobotMetaInput = {
+  name: 'AiChatRobot',
+  allowed_for_url_transform: true,
+  bytescount: 1,
+  discount_factor: 1,
+  discount_pct: 0,
+  minimum_charge: 0,
+  output_factor: 0.6,
+  purpose_sentence: 'generates AI chat responses from prompts',
+  purpose_verb: 'generate',
+  purpose_word: 'generate',
+  purpose_words: 'Generate AI chat responses',
+  service_slug: 'artificial-intelligence',
+  slot_count: 10,
+  title: 'Generate AI chat responses',
+  typical_file_size_mb: 0.01,
+  typical_file_type: 'document',
+  priceFactor: 1,
+  queueSlotCount: 10,
+  // Is this a sensbile minimum charge? What if the customer supplies their own keys? Is it low enough for these cases?
+  minimumChargeUsd: 0.06,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'alpha',
+}
+
+export const vendorModelSchema = z
+  .string()
+  .regex(/^[a-z]+\/[a-z0-9.-]+$/, 'Must be in format "vendor/model"')
+  .refine(
+    (val) => {
+      const [vendor, model] = val.split('/')
+      if (vendor === 'anthropic') {
+        return model === 'claude-4-sonnet-20250514' || model === 'claude-4-opus-20250514'
+      }
+      if (vendor === 'openai') {
+        return (
+          model === 'gpt-4.1-2025-04-14' ||
+          model === 'chatgpt-4o-latest' ||
+          model === 'o3-2025-04-16' ||
+          model === 'gpt-4o-audio-preview'
+        )
+      }
+      if (vendor === 'google') {
+        return model === 'gemini-2.5-pro'
+      }
+      if (vendor === 'moonshot') {
+        return model === 'kimi-k2'
+      }
+      return false
+    },
+    {
+      message:
+        'Invalid vendor/model combination. Supported: anthropic/claude-4-sonnet-20250514, anthropic/claude-4-opus-20250514, openai/gpt-4.1-2025-04-14, openai/chatgpt-4o-latest, openai/o3-2025-04-16, openai/gpt-4o-audio-preview, google/gemini-2.5-pro, moonshot/kimi-k2',
+    },
+  )
+
+export type VendorModel = z.infer<typeof vendorModelSchema>
+
+/**
+ * Model capabilities for /ai/chat. This centralizes which models support which input types.
+ * Key format: 'vendor/model'
+ */
+export const MODEL_CAPABILITIES: Record<string, { pdf: boolean; image: boolean }> = {
+  'anthropic/claude-4-sonnet-20250514': { pdf: true, image: true },
+  'anthropic/claude-4-opus-20250514': { pdf: true, image: true },
+  'google/gemini-2.5-pro': { pdf: true, image: true },
+  'openai/gpt-4.1-2025-04-14': { pdf: false, image: true },
+  'openai/chatgpt-4o-latest': { pdf: false, image: true },
+  'openai/o3-2025-04-16': { pdf: false, image: true },
+  'openai/gpt-4o-audio-preview': { pdf: false, image: false },
+  'moonshot/kimi-k2': { pdf: false, image: false },
+}
+
+export const robotAiChatInstructionsSchema = robotBase
+  .merge(robotUse)
+  .extend({
+    robot: z.literal('/ai/chat'),
+    // TODO: Is the auto mode yet implemented?
+    model: z
+      .union([vendorModelSchema, z.literal('auto')])
+      .default('auto')
+      .describe(
+        'The model to use. Transloadit can pick the best model for the job if you set this to "auto".',
+      ),
+    format: z.enum(['json', 'text', 'meta']).default('json'),
+    return_messages: z.enum(['all', 'last']).default('last'),
+    schema: z.string().optional().describe('The JSON Schema that the LLM should output'),
+    messages: z
+      .union([z.string(), z.array(coreMessageSchema)])
+      .describe('The prompt, or message history to send to the LLM.'),
+    system_message: z
+      .string()
+      .optional()
+      .describe('Set the system/developer prompt, if the model allows it'),
+    credentials: z
+      .union([z.string(), z.array(z.string())])
+      .optional()
+      .describe('Names of template credentials to make available to the robot.'),
+    mcp_servers: z
+      .array(
+        z.object({
+          type: z.enum(['sse', 'http']),
+          url: z.string(),
+          headers: z.record(z.string()).optional(),
+        }),
+      )
+      .optional()
+      .describe('The MCP servers to use. This is used to call tools from the LLM.'),
+  })
+  .strict()
+
+export const robotAiChatInstructionsWithHiddenFieldsSchema = robotAiChatInstructionsSchema.extend({
+  result: z.union([z.literal('debug'), robotAiChatInstructionsSchema.shape.result]),
+  provider: z
+    .string()
+    .optional()
+    .describe(
+      'Where to run the model. By the default, it is the vendor. For instance, anthropic:claude* runs on the Anthropic API. But, Claude could also be run on AWS Bedrock. This is a hidden placeholder for now, but will be used in the future to allow for more flexibility in where to run models. ',
+    ),
+  // These are listed here because we don't have these properties in the public documentation.
+  // They should set these keys using template credentials.
+  openai_api_key: z.string().optional().describe('The API key to use for the OpenAI API.'),
+  anthropic_api_key: z.string().optional().describe('The API key to use for the Anthropic API.'),
+  deepseek_api_key: z.string().optional().describe('The API key to use for the DeepSeek API.'),
+  google_generative_ai_api_key: z
+    .string()
+    .optional()
+    .describe('The API key to use for the Google Generative AI API.'),
+  xai_api_key: z.string().optional().describe('The API key to use for the xAI API.'),
+})
+
+export type RobotAiChatInstructions = z.infer<typeof robotAiChatInstructionsSchema>
+
+export type RobotAiChatInstructionsWithHiddenFields = z.infer<
+  typeof robotAiChatInstructionsWithHiddenFieldsSchema
+>
+
+export type RobotAiChatInstructionsWithHiddenFieldsInput = z.input<
+  typeof robotAiChatInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotAiChatInstructionsSchema = interpolateRobot(
+  robotAiChatInstructionsSchema,
+)
+export type InterpolatableRobotAiChatInstructions = z.infer<
+  typeof interpolatableRobotAiChatInstructionsSchema
+>
+export type InterpolatableRobotAiChatInstructionsInput = z.input<
+  typeof interpolatableRobotAiChatInstructionsSchema
+>
+
+export const interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotAiChatInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotAiChatInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotAiChatInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema
+>

package/src/alphalib/types/robots/assembly-savejson.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod'
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import { interpolateRobot, robotBase } from './_instructions-primitives.ts'
+
+// @ts-expect-error - AssemblySavejsonRobot is not ready yet @TODO please supply missing keys
+export const meta: RobotMetaInput = {
+  name: 'AssemblySavejsonRobot',
+  priceFactor: 0,
+  queueSlotCount: 5,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: false,
+  isInternal: true,
+  stage: 'ga',
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+}
+
+export const robotAssemblySavejsonInstructionsSchema = robotBase
+  .extend({
+    robot: z.literal('/assembly/savejson').describe(`
+TODO: Add robot description here
+`),
+  })
+  .strict()
+
+export type RobotAssemblySavejsonInstructions = z.infer<
+  typeof robotAssemblySavejsonInstructionsSchema
+>
+
+export const interpolatableRobotAssemblySavejsonInstructionsSchema = interpolateRobot(
+  robotAssemblySavejsonInstructionsSchema,
+)
+export type InterpolatableRobotAssemblySavejsonInstructions =
+  InterpolatableRobotAssemblySavejsonInstructionsInput
+
+export type InterpolatableRobotAssemblySavejsonInstructionsInput = z.input<
+  typeof interpolatableRobotAssemblySavejsonInstructionsSchema
+>

package/src/alphalib/types/robots/audio-artwork.ts

@@ -0,0 +1,107 @@
+import { z } from 'zod'
+
+import { stackVersions } from '../stackVersions.ts'
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  interpolateRobot,
+  robotBase,
+  robotFFmpegAudio,
+  robotUse,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  allowed_for_url_transform: true,
+  bytescount: 1,
+  discount_factor: 1,
+  discount_pct: 0,
+  example_code: {
+    steps: {
+      artwork_extracted: {
+        robot: '/audio/artwork',
+        use: ':original',
+        ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
+      },
+    },
+  },
+  example_code_description: 'Extract embedded cover artwork from uploaded audio files:',
+  minimum_charge: 0,
+  output_factor: 0.8,
+  override_lvl1: 'Audio Encoding',
+  purpose_sentence:
+    'extracts the embedded cover artwork from audio files and allows you to pipe it into other Steps, for example into /image/resize Steps. It can also insert images into audio files as cover artwork',
+  purpose_verb: 'extract',
+  purpose_word: 'extract/insert artwork',
+  purpose_words: 'Extract or insert audio artwork',
+  service_slug: 'audio-encoding',
+  slot_count: 20,
+  title: 'Extract or insert audio artwork',
+  typical_file_size_mb: 3.8,
+  typical_file_type: 'audio file',
+  uses_tools: ['ffmpeg'],
+  name: 'AudioArtworkRobot',
+  priceFactor: 1,
+  queueSlotCount: 20,
+  isAllowedForUrlTransform: true,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotAudioArtworkInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(robotFFmpegAudio)
+  .extend({
+    robot: z.literal('/audio/artwork').describe(`
+For extraction, this <dfn>Robot</dfn> uses the image format embedded within the audio file — most often, this is JPEG.
+
+If you need the image in a different format, pipe the result of this <dfn>Robot</dfn> into [🤖/image/resize](/docs/robots/image-resize/).
+
+The \`method\` parameter determines whether to extract or insert.
+`),
+    method: z
+      .enum(['extract', 'insert'])
+      .default('extract')
+      .describe(`
+What should be done with the audio file. A value of \`"extract"\` means audio artwork will be extracted. A value of \`"insert"\` means the provided image will be inserted as audio artwork.
+`),
+    change_format_if_necessary: z
+      .boolean()
+      .default(false)
+      .describe(`
+Whether the original file should be transcoded into a new format if there is an issue with the original file.
+`),
+  })
+  .strict()
+
+export const robotAudioArtworkInstructionsWithHiddenFieldsSchema =
+  robotAudioArtworkInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotAudioArtworkInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotAudioArtworkInstructions = z.infer<typeof robotAudioArtworkInstructionsSchema>
+export type RobotAudioArtworkInstructionsWithHiddenFields = z.infer<
+  typeof robotAudioArtworkInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotAudioArtworkInstructionsSchema = interpolateRobot(
+  robotAudioArtworkInstructionsSchema,
+)
+export type InterpolatableRobotAudioArtworkInstructions =
+  InterpolatableRobotAudioArtworkInstructionsInput
+
+export type InterpolatableRobotAudioArtworkInstructionsInput = z.input<
+  typeof interpolatableRobotAudioArtworkInstructionsSchema
+>
+
+export const interpolatableRobotAudioArtworkInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotAudioArtworkInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotAudioArtworkInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotAudioArtworkInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotAudioArtworkInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotAudioArtworkInstructionsWithHiddenFieldsSchema
+>

package/src/alphalib/types/robots/audio-concat.ts

@@ -0,0 +1,142 @@
+import { z } from 'zod'
+
+import { stackVersions } from '../stackVersions.ts'
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  bitrateSchema,
+  interpolateRobot,
+  robotBase,
+  robotFFmpegAudio,
+  robotUse,
+  robotUseWithHiddenFields,
+  sampleRateSchema,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  allowed_for_url_transform: false,
+  bytescount: 4,
+  discount_factor: 0.25,
+  discount_pct: 75,
+  example_code: {
+    steps: {
+      concatenated: {
+        robot: '/audio/concat',
+        use: {
+          steps: [
+            {
+              name: ':original',
+              fields: 'first_audio_file',
+              as: 'audio_1',
+            },
+            {
+              name: ':original',
+              fields: 'second_audio_file',
+              as: 'audio_2',
+            },
+            {
+              name: ':original',
+              fields: 'third_audio_file',
+              as: 'audio_3',
+            },
+          ],
+        },
+        ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
+      },
+    },
+  },
+  example_code_description:
+    'If you have a form with 3 file input fields and want to concatenate the uploaded audios in a specific order, instruct Transloadit using the `name` attribute of each input field. Use this attribute as the value for the `fields` key in the JSON, and set `as` to `audio_[[index]]`. Transloadit will concatenate the files based on the ascending index order:',
+  minimum_charge: 0,
+  output_factor: 0.8,
+  override_lvl1: 'Audio Encoding',
+  purpose_sentence: 'concatenates several audio files together',
+  purpose_verb: 'concatenate',
+  purpose_word: 'concatenate',
+  purpose_words: 'Concatenate audio',
+  service_slug: 'audio-encoding',
+  slot_count: 20,
+  title: 'Concatenate audio',
+  typical_file_size_mb: 3.8,
+  typical_file_type: 'audio file',
+  uses_tools: ['ffmpeg'],
+  name: 'AudioConcatRobot',
+  priceFactor: 4,
+  queueSlotCount: 20,
+  isAllowedForUrlTransform: false,
+  trackOutputFileSize: true,
+  isInternal: false,
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+  stage: 'ga',
+}
+
+export const robotAudioConcatInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(robotFFmpegAudio)
+  .extend({
+    result: z
+      .boolean()
+      .optional()
+      .describe('Whether the results of this Step should be present in the Assembly Status JSON'),
+    robot: z.literal('/audio/concat').describe(`
+This Robot can concatenate an almost infinite number of audio files.
+`),
+    bitrate: bitrateSchema.optional().describe(`
+Bit rate of the resulting audio file, in bits per second. If not specified will default to the bit rate of the input audio file.
+`),
+    sample_rate: sampleRateSchema.optional().describe(`
+Sample rate of the resulting audio file, in Hertz. If not specified will default to the sample rate of the input audio file.
+`),
+    audio_fade_seconds: z
+      .number()
+      .default(1)
+      .describe(`
+When used this adds an audio fade in and out effect between each section of your concatenated audio file. The float value is used, so if you want an audio delay effect of 500 milliseconds between each video section, you would select 0.5. Integer values can also be represented.
+
+This parameter does not add an audio fade effect at the beginning or end of your result audio file. If you want to do so, create an additional [🤖/audio/encode](/docs/robots/audio-encode/) <dfn>Step</dfn> and use our \`ffmpeg\` parameter as shown in this [demo](/demos/audio-encoding/ffmpeg-fade-in-and-out/).
+`),
+    crossfade: z
+      .boolean()
+      .default(false)
+      .describe(`
+When set to \`true\`, this parameter enables crossfading between concatenated audio files using FFmpeg's \`acrossfade\` filter. This creates a smooth transition where the end of one audio file overlaps and blends with the beginning of the next file.
+
+The duration of the crossfade is controlled by the \`audio_fade_seconds\` parameter (defaults to 1 second if \`audio_fade_seconds\` is 0).
+
+Note: This parameter requires at least 2 audio files to concatenate and only works with audio files, not video files.
+`),
+  })
+  .strict()
+
+export const robotAudioConcatInstructionsWithHiddenFieldsSchema = robotAudioConcatInstructionsSchema
+  .omit({ use: true })
+  .merge(robotUseWithHiddenFields)
+  .extend({
+    result: z
+      .union([z.literal('debug'), robotAudioConcatInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotAudioConcatInstructions = z.infer<typeof robotAudioConcatInstructionsSchema>
+export type RobotAudioConcatInstructionsWithHiddenFields = z.infer<
+  typeof robotAudioConcatInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotAudioConcatInstructionsSchema = interpolateRobot(
+  robotAudioConcatInstructionsSchema,
+)
+export type InterpolatableRobotAudioConcatInstructions =
+  InterpolatableRobotAudioConcatInstructionsInput
+
+export type InterpolatableRobotAudioConcatInstructionsInput = z.input<
+  typeof interpolatableRobotAudioConcatInstructionsSchema
+>
+
+export const interpolatableRobotAudioConcatInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotAudioConcatInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotAudioConcatInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotAudioConcatInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotAudioConcatInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotAudioConcatInstructionsWithHiddenFieldsSchema
+>

package/src/alphalib/types/robots/audio-encode.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod'
+
+import { stackVersions } from '../stackVersions.ts'
+import type { RobotMetaInput } from './_instructions-primitives.ts'
+import {
+  bitrateSchema,
+  interpolateRobot,
+  robotBase,
+  robotFFmpegAudio,
+  robotUse,
+  sampleRateSchema,
+} from './_instructions-primitives.ts'
+
+export const meta: RobotMetaInput = {
+  allowed_for_url_transform: false,
+  bytescount: 4,
+  discount_factor: 0.25,
+  discount_pct: 75,
+  example_code: {
+    steps: {
+      mp3_encoded: {
+        robot: '/audio/encode',
+        use: ':original',
+        preset: 'mp3',
+        bitrate: 256000,
+        ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
+      },
+    },
+  },
+  example_code_description: 'Encode uploaded audio to MP3 format at a 256 kbps bitrate:',
+  minimum_charge: 0,
+  output_factor: 0.8,
+  override_lvl1: 'Audio Encoding',
+  purpose_sentence:
+    'converts audio files into all kinds of formats for you. We provide encoding presets for the most common formats',
+  purpose_verb: 'encode',
+  purpose_word: 'encode',
+  purpose_words: 'Encode audio',
+  service_slug: 'audio-encoding',
+  slot_count: 20,
+  title: 'Encode audio',
+  typical_file_size_mb: 3.8,
+  typical_file_type: 'audio file',
+  uses_tools: ['ffmpeg'],
+  name: 'AudioEncodeRobot',
+  priceFactor: 4,
+  queueSlotCount: 20,
+  isAllowedForUrlTransform: false,
+  trackOutputFileSize: true,
+  isInternal: false,
+  stage: 'ga',
+  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+}
+
+export const robotAudioEncodeInstructionsSchema = robotBase
+  .merge(robotUse)
+  .merge(robotFFmpegAudio)
+  .extend({
+    result: z
+      .boolean()
+      .optional()
+      .describe('Whether the results of this Step should be present in the Assembly Status JSON'),
+    robot: z.literal('/audio/encode'),
+    bitrate: bitrateSchema.optional().describe(`
+Bit rate of the resulting audio file, in bits per second. If not specified will default to the bit rate of the input audio file.
+`),
+    sample_rate: sampleRateSchema.optional().describe(`
+Sample rate of the resulting audio file, in Hertz. If not specified will default to the sample rate of the input audio file.
+`),
+  })
+  .strict()
+
+export const robotAudioEncodeInstructionsWithHiddenFieldsSchema =
+  robotAudioEncodeInstructionsSchema.extend({
+    result: z
+      .union([z.literal('debug'), robotAudioEncodeInstructionsSchema.shape.result])
+      .optional(),
+  })
+
+export type RobotAudioEncodeInstructions = z.infer<typeof robotAudioEncodeInstructionsSchema>
+export type RobotAudioEncodeInstructionsWithHiddenFields = z.infer<
+  typeof robotAudioEncodeInstructionsWithHiddenFieldsSchema
+>
+
+export const interpolatableRobotAudioEncodeInstructionsSchema = interpolateRobot(
+  robotAudioEncodeInstructionsSchema,
+)
+export type InterpolatableRobotAudioEncodeInstructions =
+  InterpolatableRobotAudioEncodeInstructionsInput
+
+export type InterpolatableRobotAudioEncodeInstructionsInput = z.input<
+  typeof interpolatableRobotAudioEncodeInstructionsSchema
+>
+
+export const interpolatableRobotAudioEncodeInstructionsWithHiddenFieldsSchema = interpolateRobot(
+  robotAudioEncodeInstructionsWithHiddenFieldsSchema,
+)
+export type InterpolatableRobotAudioEncodeInstructionsWithHiddenFields = z.infer<
+  typeof interpolatableRobotAudioEncodeInstructionsWithHiddenFieldsSchema
+>
+export type InterpolatableRobotAudioEncodeInstructionsWithHiddenFieldsInput = z.input<
+  typeof interpolatableRobotAudioEncodeInstructionsWithHiddenFieldsSchema
+>