@transloadit/zod 4.3.0 → 4.3.2

package/dist/v4/robots/_instructions-primitives.js

@@ -19,12 +19,20 @@ export const robotNames = z.enum([
     'AudioConcatRobot',
     'AudioMergeRobot',
     'AudioArtworkRobot',
+    'AudioSplitRobot',
+    'BoxImportRobot',
+    'BoxStoreRobot',
+    'VideoArtworkRobot',
     'ImageFacedetectRobot',
     'ImageDescribeRobot',
+    'ImageCopyrightdetectRobot',
     'ImageOcrRobot',
     'ImageBgremoveRobot',
+    'ImageUpscaleRobot',
     'ImageGenerateRobot',
+    'ImageEnhanceRobot',
     'DocumentOcrRobot',
+    'DocumentOptimizeRobot',
     'SpeechTranscribeRobot',
     'VideoThumbsRobot',
     'FileVirusscanRobot',
@@ -49,10 +57,12 @@ export const robotNames = z.enum([
     'BackblazeImportRobot',
     'BackblazeStoreRobot',
     'MinioImportRobot',
+    'MegaImportRobot',
     'TigrisImportRobot',
     'CloudflareImportRobot',
     'SupabaseImportRobot',
     'MinioStoreRobot',
+    'MegaStoreRobot',
     'TigrisStoreRobot',
     'CloudflareStoreRobot',
     'SupabaseStoreRobot',
@@ -81,6 +91,8 @@ export const robotNames = z.enum([
     'FileHashRobot',
     'FileReadRobot',
     'VideoOndemandRobot',
+    'VideoSplitRobot',
+    'VideoGenerateRobot',
     'FileFilterRobot',
     'TextSpeakRobot',
     'TextTranslateRobot',
@@ -120,7 +132,6 @@ export const robotMetaSchema = z.object({
     importRanges: z.array(z.string()).optional(),
     extraChargeForImageResize: z.number().optional(),
     // Original keys from content repo:
-    allowed_for_url_transform: z.boolean(),
     bytescount: z.number(),
     description: z.string().optional(),
     discount_factor: z.number(),
@@ -147,6 +158,7 @@ export const robotMetaSchema = z.object({
         'convert',
         'decompress',
         'detect',
+        'enhance',
         'encode',
         'export',
         'extract',
@@ -164,6 +176,7 @@ export const robotMetaSchema = z.object({
         'scan',
         'serve',
         'speak',
+        'split',
         'subtitle',
         'take',
         'transcode',
@@ -176,6 +189,7 @@ export const robotMetaSchema = z.object({
     ]),
     purpose_word: z.string(),
     purpose_words: z.string(),
+    hideCredentialsWarning: z.boolean().optional(),
     requires_credentials: z.literal(true).optional(),
     service_slug: z.enum([
         'artificial-intelligence',
@@ -333,7 +347,8 @@ export function interpolateRecursive(schema) {
 /**
  * The robot keys specified in this array can’t be interpolated.
  */
-const uninterpolatableKeys = ['robot', 'use'];
+const uninterpolatableKeys = ['interpolate', 'robot', 'use'];
+const uninterpolatableKeySet = new Set(uninterpolatableKeys);
 export function interpolateRobot(schema) {
     const def = schema._zod.def;
     const shape = typeof def.shape === 'function'
@@ -348,8 +363,21 @@ export function interpolateRobot(schema) {
     ])))
         .strict();
 }
+const robotInterpolateBooleanSchema = z
+    .union([z.boolean(), booleanStringSchema])
+    .transform((value) => value === true || value === 'true');
+export const robotInterpolateSchema = z
+    .union([robotInterpolateBooleanSchema, z.record(z.string(), robotInterpolateBooleanSchema)])
+    .describe(`
+Controls whether Assembly Variables are interpolated for individual instruction fields.
+
+By default, most Robot instruction fields interpolate Assembly Variables. Set this to \`false\` to treat every instruction field as literal text, or set an individual field path to \`false\` to treat only that field as literal text. For Robot-specific fields that are literal by default, set this to \`true\` or set that field path to \`true\` to opt back into interpolation.
+
+Use field names such as \`path\`, or dotted paths such as \`ffmpeg.vf\` for nested objects.
+`);
 export const robotBase = z
     .object({
+    interpolate: robotInterpolateSchema.optional(),
     output_meta: z
         .union([z.record(z.string(), z.boolean()), z.boolean(), z.array(z.string())])
         .optional()
@@ -358,6 +386,8 @@ Allows you to specify a set of metadata that is more expensive on CPU power to c
 
 For images, you can add \`"has_transparency": true\` in this object to extract if the image contains transparent parts and \`"dominant_colors": true\` to extract an array of hexadecimal color codes from the image.
 
+For images, you can also add \`"blurhash": true\` to extract a [BlurHash](https://blurha.sh) string — a compact representation of a placeholder for the image, useful for showing a blurred preview while the full image loads.
+
 For videos, you can add the \`"colorspace: true"\` parameter to extract the colorspace of the output video.
 
 For audio, you can add \`"mean_volume": true\` to get a single value representing the mean average volume of the audio file.
@@ -468,6 +498,22 @@ Specifies which Step(s) to use as input.
     ]
   }
   \`\`\`
+- You can also tag an input Step with \`as\` to pass semantic intent to robots:
+- You can also tag input Steps with \`as\` to pass semantic intent to robots:
+  \`\`\`json
+  {
+    "use": [
+      {
+        "name": ":original",
+        "as": "image"
+      },
+      {
+        "name": ":original",
+        "as": "mask"
+      }
+    ]
+  }
+  \`\`\`
 
 > [!Tip]
 > That's likely all you need to know about \`use\`, but you can view [Advanced use cases](/docs/topics/use-parameter/).
@@ -493,6 +539,22 @@ Specifies which Step(s) to use as input.
     ]
   }
   \`\`\`
+- You can also tag an input Step with \`as\` to pass semantic intent to robots:
+- You can also tag input Steps with \`as\` to pass semantic intent to robots:
+  \`\`\`json
+  {
+    "use": [
+      {
+        "name": ":original",
+        "as": "image"
+      },
+      {
+        "name": ":original",
+        "as": "mask"
+      }
+    ]
+  }
+  \`\`\`
 
 > [!Tip]
 > That's likely all you need to know about \`use\`, but you can view [Advanced use cases](/docs/topics/use-parameter/).
@@ -512,7 +574,7 @@ export const complexWidthSchema = z.preprocess((val) => {
         return num;
     }
     return val;
-}, z.number().int().min(1).max(7680));
+}, z.number().int().min(1).max(25_000));
 export const complexHeightSchema = z.preprocess((val) => {
     if (typeof val === 'string' && val.startsWith('${')) {
         return val;
@@ -525,7 +587,7 @@ export const complexHeightSchema = z.preprocess((val) => {
         return num;
     }
     return val;
-}, z.number().int().min(1).max(4320));
+}, z.number().int().min(1).max(25_000));
 export const robotFFmpeg = z.object({
     ffmpeg: z
         .object({
@@ -641,7 +703,7 @@ A parameter object to be passed to FFmpeg. If a preset is used, the options spec
     ffmpeg_stack: z
         // Any semver in range is allowed and normalized. The enum is used for editor completions.
         .union([z.enum(['v5', 'v6', 'v7']), z.string().regex(/^v?[567](\.\d+)?(\.\d+)?$/)])
-        .default('v5.0.0')
+        .default('v6.0.0')
         .describe(`
 Selects the FFmpeg stack version to use for encoding. These versions reflect real FFmpeg versions. We currently recommend to use "v6.0.0".
 `),
@@ -1061,6 +1123,22 @@ While we recommend to use <dfn>Template Credentials</dfn> at all times, some use
     bucket: z.string().optional(),
     app_key_id: z.string().optional(),
     app_key: z.string().optional(),
+})
+    .strict();
+export const boxBase = z
+    .object({
+    credentials: z
+        .string()
+        .optional()
+        .describe(`
+Create a Box app in the [Box Developer Console](https://app.box.com/developers/console) using **Server Authentication (JWT)**.
+
+Generate a public/private keypair for that app. Box will download a JSON config file (with \`boxAppSettings\` and \`appAuth\`) that includes your JWT private key material.
+
+In your Transloadit account, create [Template Credentials](/c/template-credentials/) of type Box and paste that full JSON file into \`key_file_contents\`. Then set this \`credentials\` parameter to the Template Credentials name.
+
+If your Box enterprise requires it, make sure the app is authorized by an admin before using it in production.
+`),
 })
     .strict();
 export const cloudfilesBase = z
@@ -1184,6 +1262,28 @@ While we recommend to use <dfn>Template Credentials</dfn> at all times, some use
     secret: z.string().optional(),
 })
     .strict();
+export const megaBase = z
+    .object({
+    credentials: z
+        .string()
+        .optional()
+        .describe(`
+Please create your associated <dfn>Template Credentials</dfn> in your Transloadit account and use the name of your <dfn>Template Credentials</dfn> as this parameter's value. They will contain the values for your MEGA object storage bucket, Key, Secret and Bucket region.
+
+While we recommend to use <dfn>Template Credentials</dfn> at all times, some use cases demand dynamic credentials for which using <dfn>Template Credentials</dfn> is too unwieldy because of their static nature. If you have this requirement, feel free to use the following parameters instead: \`"bucket"\`, \`"bucket_region"\`, \`"key"\`, \`"secret"\`.
+`),
+    bucket: z.string().optional(),
+    bucket_region: z
+        .string()
+        .optional()
+        .describe(`
+The region where the bucket is located.
+`),
+    host: z.string().optional(),
+    key: z.string().optional(),
+    secret: z.string().optional(),
+})
+    .strict();
 export const s3Base = z
     .object({
     credentials: z

package/dist/v4/robots/ai-chat.d.ts

@@ -9,9 +9,17 @@ export declare const MODEL_CAPABILITIES: Record<string, {
     pdf: boolean;
     image: boolean;
 }>;
+export declare const AI_CHAT_DEFAULT_MODEL = "openai/gpt-5.5";
 export declare const vendorModelSchema: z.ZodString;
 export type VendorModel = z.infer<typeof vendorModelSchema>;
 export declare const robotAiChatInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
@@ -44,8 +52,8 @@ export declare const robotAiChatInstructionsSchema: z.ZodObject<{
         json: "json";
     }>>;
     return_messages: z.ZodDefault<z.ZodEnum<{
-        last: "last";
         all: "all";
+        last: "last";
     }>>;
     schema: z.ZodOptional<z.ZodString>;
     messages: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -105,6 +113,12 @@ export declare const robotAiChatInstructionsSchema: z.ZodObject<{
         experimental_providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>>>;
     }, z.core.$strip>], "role">>]>;
     system_message: z.ZodOptional<z.ZodString>;
+    reasoning_effort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        xhigh: "xhigh";
+        medium: "medium";
+    }>>;
     credentials: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     test_credentials: z.ZodOptional<z.ZodBoolean>;
     mcp_servers: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -114,9 +128,20 @@ export declare const robotAiChatInstructionsSchema: z.ZodObject<{
         }>;
         url: z.ZodString;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        auth: z.ZodOptional<z.ZodEnum<{
+            transloadit: "transloadit";
+        }>>;
+        allowed_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
 }, z.core.$strict>;
 export declare const robotAiChatInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -148,8 +173,8 @@ export declare const robotAiChatInstructionsWithHiddenFieldsSchema: z.ZodObject<
         json: "json";
     }>>;
     return_messages: z.ZodDefault<z.ZodEnum<{
-        last: "last";
         all: "all";
+        last: "last";
     }>>;
     schema: z.ZodOptional<z.ZodString>;
     messages: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -209,6 +234,12 @@ export declare const robotAiChatInstructionsWithHiddenFieldsSchema: z.ZodObject<
         experimental_providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>>>;
     }, z.core.$strip>], "role">>]>;
     system_message: z.ZodOptional<z.ZodString>;
+    reasoning_effort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        low: "low";
+        xhigh: "xhigh";
+        medium: "medium";
+    }>>;
     credentials: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     test_credentials: z.ZodOptional<z.ZodBoolean>;
     mcp_servers: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -218,6 +249,10 @@ export declare const robotAiChatInstructionsWithHiddenFieldsSchema: z.ZodObject<
         }>;
         url: z.ZodString;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        auth: z.ZodOptional<z.ZodEnum<{
+            transloadit: "transloadit";
+        }>>;
+        allowed_tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
     result: z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>;
     provider: z.ZodOptional<z.ZodString>;
@@ -231,6 +266,13 @@ export type RobotAiChatInstructions = z.infer<typeof robotAiChatInstructionsSche
 export type RobotAiChatInstructionsWithHiddenFields = z.infer<typeof robotAiChatInstructionsWithHiddenFieldsSchema>;
 export type RobotAiChatInstructionsWithHiddenFieldsInput = z.input<typeof robotAiChatInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotAiChatInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
@@ -263,8 +305,8 @@ export declare const interpolatableRobotAiChatInstructionsSchema: z.ZodObject<{
         json: "json";
     }>]>>;
     return_messages: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        last: "last";
         all: "all";
+        last: "last";
     }>]>>;
     schema: z.ZodOptional<z.ZodString>;
     messages: z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -324,6 +366,12 @@ export declare const interpolatableRobotAiChatInstructionsSchema: z.ZodObject<{
         experimental_providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>>>;
     }, z.core.$strip>], "role">>]>]>;
     system_message: z.ZodOptional<z.ZodString>;
+    reasoning_effort: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        high: "high";
+        low: "low";
+        xhigh: "xhigh";
+        medium: "medium";
+    }>]>>;
     credentials: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     test_credentials: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     mcp_servers: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
@@ -333,11 +381,22 @@ export declare const interpolatableRobotAiChatInstructionsSchema: z.ZodObject<{
         }>]>;
         url: z.ZodString;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        auth: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+            transloadit: "transloadit";
+        }>]>>;
+        allowed_tools: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>>;
     }, z.core.$strip>]>>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotAiChatInstructions = z.infer<typeof interpolatableRobotAiChatInstructionsSchema>;
 export type InterpolatableRobotAiChatInstructionsInput = z.input<typeof interpolatableRobotAiChatInstructionsSchema>;
 export declare const interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";
@@ -369,8 +428,8 @@ export declare const interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema
         json: "json";
     }>]>>;
     return_messages: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        last: "last";
         all: "all";
+        last: "last";
     }>]>>;
     schema: z.ZodOptional<z.ZodString>;
     messages: z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -430,6 +489,12 @@ export declare const interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema
         experimental_providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>>>;
     }, z.core.$strip>], "role">>]>]>;
     system_message: z.ZodOptional<z.ZodString>;
+    reasoning_effort: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        high: "high";
+        low: "low";
+        xhigh: "xhigh";
+        medium: "medium";
+    }>]>>;
     credentials: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     test_credentials: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     mcp_servers: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
@@ -439,6 +504,10 @@ export declare const interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema
         }>]>;
         url: z.ZodString;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        auth: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+            transloadit: "transloadit";
+        }>]>>;
+        allowed_tools: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>>;
     }, z.core.$strip>]>>]>>;
     result: z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>;
     provider: z.ZodOptional<z.ZodString>;

package/dist/v4/robots/ai-chat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ai-chat.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/ai-chat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAC1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAkHnE,eAAO,MAAM,IAAI,EAAE,cA0BlB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAe/E,CAAA;AAID,eAAO,MAAM,iBAAiB,aAK1B,CAAA;AAEJ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAwC/B,CAAA;AAEX,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkBxD,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEnF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,6CAA6C,CACrD,CAAA;AAED,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEvD,CAAA;AACD,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,2CAA2C,CACnD,CAAA;AACD,MAAM,MAAM,0CAA0C,GAAG,CAAC,CAAC,KAAK,CAC9D,OAAO,2CAA2C,CACnD,CAAA;AAED,eAAO,MAAM,2DAA2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEvE,CAAA;AACD,MAAM,MAAM,qDAAqD,GAAG,CAAC,CAAC,KAAK,CACzE,OAAO,2DAA2D,CACnE,CAAA;AACD,MAAM,MAAM,0DAA0D,GAAG,CAAC,CAAC,KAAK,CAC9E,OAAO,2DAA2D,CACnE,CAAA"}
+{"version":3,"file":"ai-chat.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/ai-chat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAC1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAkHnE,eAAO,MAAM,IAAI,EAAE,cAoClB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAqB/E,CAAA;AAKD,eAAO,MAAM,qBAAqB,mBAA6D,CAAA;AAI/F,eAAO,MAAM,iBAAiB,aAK1B,CAAA;AAEJ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6D/B,CAAA;AAEX,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkBxD,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEnF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,6CAA6C,CACrD,CAAA;AAED,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEvD,CAAA;AACD,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,2CAA2C,CACnD,CAAA;AACD,MAAM,MAAM,0CAA0C,GAAG,CAAC,CAAC,KAAK,CAC9D,OAAO,2CAA2C,CACnD,CAAA;AAED,eAAO,MAAM,2DAA2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEvE,CAAA;AACD,MAAM,MAAM,qDAAqD,GAAG,CAAC,CAAC,KAAK,CACzE,OAAO,2DAA2D,CACnE,CAAA;AACD,MAAM,MAAM,0DAA0D,GAAG,CAAC,CAAC,KAAK,CAC9E,OAAO,2DAA2D,CACnE,CAAA"}

package/dist/v4/robots/ai-chat.js

@@ -105,10 +105,19 @@ const coreMessageSchema = z.discriminatedUnion('role', [
 ]);
 export const meta = {
     name: 'AiChatRobot',
-    allowed_for_url_transform: true,
     bytescount: 1,
     discount_factor: 1,
     discount_pct: 0,
+    example_code: {
+        steps: {
+            reply: {
+                robot: '/ai/chat',
+                model: 'auto',
+                messages: 'Summarize this in one sentence: Transloadit handles uploads and media processing.',
+            },
+        },
+    },
+    example_code_description: 'Generate a concise AI response from a text prompt:',
     minimum_charge: 0,
     output_factor: 0.6,
     purpose_sentence: 'generates AI chat responses from prompts',
@@ -122,7 +131,7 @@ export const meta = {
     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?
+    // Is this a sensible minimum charge? What if the customer supplies their own keys? Is it low enough for these cases?
     minimumChargeUsd: 0.06,
     isAllowedForUrlTransform: true,
     trackOutputFileSize: true,
@@ -139,6 +148,8 @@ export const MODEL_CAPABILITIES = {
     'anthropic/claude-4-opus-20250514': { pdf: true, image: true },
     'anthropic/claude-sonnet-4-5': { pdf: true, image: true },
     'anthropic/claude-opus-4-5': { pdf: true, image: true },
+    'anthropic/claude-opus-4-6': { pdf: true, image: true },
+    'anthropic/claude-opus-4-7': { 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 },
@@ -147,9 +158,17 @@ export const MODEL_CAPABILITIES = {
     'openai/gpt-5.2-2025-12-11': { pdf: false, image: true },
     'openai/gpt-5.2-chat-latest': { pdf: false, image: true },
     'openai/gpt-5.2-pro': { pdf: false, image: true },
+    'openai/gpt-5.5': { pdf: false, image: true },
+    'openai/gpt-5.4': { pdf: false, image: true },
+    'openai/gpt-5.4-mini': { pdf: false, image: true },
+    'openai/gpt-5.4-nano': { pdf: false, image: true },
     'google/gemini-2.5-pro': { pdf: true, image: true },
     'moonshot/kimi-k2': { pdf: false, image: false },
 };
+// Default model for /ai/chat when `model: "auto"` (or unset).
+// 2026-04-29: default is GPT-5.5 (intentional; aligns with our current recommended OpenAI
+// flagship model). Keep this aligned with MODEL_CAPABILITIES.
+export const AI_CHAT_DEFAULT_MODEL = 'openai/gpt-5.5';
 const supportedModelsList = Object.keys(MODEL_CAPABILITIES);
 export const vendorModelSchema = z
     .string()
@@ -161,7 +180,7 @@ export const robotAiChatInstructionsSchema = robotBase
     .merge(robotUse)
     .extend({
     robot: z.literal('/ai/chat'),
-    // TODO: Is the auto mode yet implemented?
+    // NOTE: model:"auto" is resolved server-side to AI_CHAT_DEFAULT_MODEL for now.
     model: z
         .union([vendorModelSchema, z.literal('auto')])
         .default('auto')
@@ -175,23 +194,32 @@ export const robotAiChatInstructionsSchema = robotBase
     system_message: z
         .string()
         .optional()
-        .describe('Set the system/developer prompt, if the model allows it'),
+        .describe('Set the system/developer prompt, if the model allows it. If this prompt contains literal documentation or code examples with `${...}` syntax, set `interpolate.system_message` to `false`.'),
+    reasoning_effort: z
+        .enum(['xhigh', 'high', 'medium', 'low'])
+        .optional()
+        .describe('Controls how much effort the model spends on reasoning. Higher values produce more thorough responses but cost more tokens. Applies to models that support extended thinking (OpenAI o-series, GPT-5.x, Anthropic Claude with thinking). If omitted, the model default is used.'),
     credentials: z
         .union([z.string(), z.array(z.string())])
         .optional()
-        .describe('Names of template credentials to make available to the robot.'),
+        .describe('Names of template credentials to make available to the robot. When using your own AI provider keys, Transloadit charges a 10% markup (minimum $0.0005 per request).'),
     test_credentials: z
         .boolean()
         .optional()
-        .describe('Use Transloadit-provided credentials for testing.'),
+        .describe('Use Transloadit-provided credentials for testing. Usage is billed at provider cost plus a 10% markup (minimum $0.0005 per request).'),
     mcp_servers: z
         .array(z.object({
         type: z.enum(['sse', 'http']),
         url: z.string(),
         headers: z.record(z.string(), z.string()).optional(),
+        auth: z.enum(['transloadit']).optional(),
+        allowed_tools: z
+            .array(z.string())
+            .optional()
+            .describe('Optional allowlist of tool names to expose from this MCP server. If omitted, all tools exposed by the server are available to the model.'),
     }))
         .optional()
-        .describe('The MCP servers to use. This is used to call tools from the LLM.'),
+        .describe('The MCP servers to use for tool calling. You can use any MCP server reachable from your environment. Use `headers` to pass server-specific auth (for example `Authorization: Bearer <token>`). For Transloadit\'s MCP server: Bearer tokens minted via `/token` satisfy Signature Authentication (signature checks apply only to key/secret requests). `auth: "transloadit"` is reserved for API2-managed auth to Transloadit-hosted MCP servers.'),
 })
     .strict();
 export const robotAiChatInstructionsWithHiddenFieldsSchema = robotAiChatInstructionsSchema.extend({

package/dist/v4/robots/assembly-savejson.d.ts

@@ -2,6 +2,13 @@ import { z } from 'zod/v4';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotAssemblySavejsonInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
@@ -16,6 +23,13 @@ export declare const robotAssemblySavejsonInstructionsSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type RobotAssemblySavejsonInstructions = z.infer<typeof robotAssemblySavejsonInstructionsSchema>;
 export declare const interpolatableRobotAssemblySavejsonInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{

package/dist/v4/robots/assembly-savejson.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assembly-savejson.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/assembly-savejson.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAC1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAInE,eAAO,MAAM,IAAI,EAAE,cASlB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;kBAMzC,CAAA;AAEX,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AAED,eAAO,MAAM,qDAAqD;;;;;;;;;;;;kBAEjE,CAAA;AACD,MAAM,MAAM,+CAA+C,GACzD,oDAAoD,CAAA;AAEtD,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CACxE,OAAO,qDAAqD,CAC7D,CAAA"}
+{"version":3,"file":"assembly-savejson.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/assembly-savejson.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAC1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAgClB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;kBAMzC,CAAA;AAEX,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AAED,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;kBAEjE,CAAA;AACD,MAAM,MAAM,+CAA+C,GACzD,oDAAoD,CAAA;AAEtD,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CACxE,OAAO,qDAAqD,CAC7D,CAAA"}

package/dist/v4/robots/assembly-savejson.js

@@ -1,7 +1,29 @@
 import { z } from 'zod/v4';
 import { interpolateRobot, robotBase } from "./_instructions-primitives.js";
-// @ts-expect-error - AssemblySavejsonRobot is not ready yet @TODO please supply missing keys
 export const meta = {
+    bytescount: 0,
+    discount_factor: 0,
+    discount_pct: 100,
+    example_code: {
+        steps: {
+            save_json: {
+                robot: '/assembly/savejson',
+            },
+        },
+    },
+    example_code_description: 'Save Assembly result data as JSON:',
+    minimum_charge: 0,
+    output_factor: 1,
+    override_lvl1: 'File Exporting',
+    purpose_sentence: 'exports Assembly status data as JSON',
+    purpose_verb: 'export',
+    purpose_word: 'Assembly status',
+    purpose_words: 'Export Assembly status JSON',
+    service_slug: 'file-exporting',
+    slot_count: 5,
+    title: 'Export Assembly status JSON',
+    typical_file_size_mb: 0.1,
+    typical_file_type: 'file',
     name: 'AssemblySavejsonRobot',
     priceFactor: 0,
     queueSlotCount: 5,

package/dist/v4/robots/audio-artwork.d.ts

@@ -2,6 +2,13 @@ import { z } from 'zod/v4';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotAudioArtworkInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
@@ -177,6 +184,13 @@ export declare const robotAudioArtworkInstructionsSchema: z.ZodObject<{
     change_format_if_necessary: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strict>;
 export declare const robotAudioArtworkInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -354,6 +368,13 @@ export declare const robotAudioArtworkInstructionsWithHiddenFieldsSchema: z.ZodO
 export type RobotAudioArtworkInstructions = z.infer<typeof robotAudioArtworkInstructionsSchema>;
 export type RobotAudioArtworkInstructionsWithHiddenFields = z.infer<typeof robotAudioArtworkInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotAudioArtworkInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
@@ -531,6 +552,13 @@ export declare const interpolatableRobotAudioArtworkInstructionsSchema: z.ZodObj
 export type InterpolatableRobotAudioArtworkInstructions = InterpolatableRobotAudioArtworkInstructionsInput;
 export type InterpolatableRobotAudioArtworkInstructionsInput = z.input<typeof interpolatableRobotAudioArtworkInstructionsSchema>;
 export declare const interpolatableRobotAudioArtworkInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";