@transloadit/zod 4.3.3 → 4.3.5

package/dist/v4/robots/image-describe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-describe.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-describe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,IAAI,EAAE,cAwClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkCtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}
+{"version":3,"file":"image-describe.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-describe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAW1B,eAAO,MAAM,IAAI,EAAE,cAwClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkCtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}

package/dist/v4/robots/image-describe.js

@@ -1,5 +1,5 @@
 import { z } from 'zod/v4';
-import { aiProviderSchema, granularitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { autoProviderDescription, awsGcpAiProviderSchema, granularitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
     bytescount: 1,
     discount_factor: 1,
@@ -46,10 +46,10 @@ export const robotImageDescribeInstructionsSchema = robotBase
     robot: z.literal('/image/describe').describe(`
 You can use the labels that we return in your application to automatically classify images. You can also pass the labels down to other <dfn>Robots</dfn> to filter images that contain (or do not contain) certain content.
 `),
-    provider: aiProviderSchema.optional().describe(`
-Which AI provider to leverage.
+    provider: awsGcpAiProviderSchema.describe(`
+${autoProviderDescription}
 
-Transloadit outsources this task and abstracts the interface so you can expect the same data structures, but different latencies and information being returned. Different cloud vendors have different areas they shine in, and we recommend to try out and see what yields the best results for your use case.
+Set this to \`"aws"\` or \`"gcp"\` to force a specific provider.
 `),
     granularity: granularitySchema.describe(`
 Whether to return a full response (\`"full"\`) including confidence percentages for each found label, or just a flat list of labels (\`"list"\`).

package/dist/v4/robots/image-facedetect.d.ts

@@ -1,5 +1,22 @@
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
+export declare const imageFacedetectFaceSelectionModes: readonly ["each", "group", "max-confidence", "max-size"];
+export declare const imageFacedetectFaceSelectionModeSchema: z.ZodEnum<{
+    each: "each";
+    group: "group";
+    "max-confidence": "max-confidence";
+    "max-size": "max-size";
+}>;
+export declare const imageFacedetectFaceCoordinatesSchema: z.ZodObject<{
+    confidence: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodNumber;
+    width: z.ZodNumber;
+    x1: z.ZodNumber;
+    x2: z.ZodOptional<z.ZodNumber>;
+    y1: z.ZodNumber;
+    y2: z.ZodOptional<z.ZodNumber>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type ImageFacedetectFaceCoordinates = z.infer<typeof imageFacedetectFaceCoordinatesSchema>;
 export declare const meta: RobotMetaInput;
 export declare const robotImageFacedetectInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
@@ -34,12 +51,10 @@ export declare const robotImageFacedetectInstructionsSchema: z.ZodObject<{
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/facedetect">;
-    provider: z.ZodOptional<z.ZodEnum<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
         aws: "aws";
         gcp: "gcp";
-        replicate: "replicate";
-        fal: "fal";
-        transloadit: "transloadit";
     }>>;
     crop: z.ZodDefault<z.ZodBoolean>;
     crop_padding: z.ZodDefault<z.ZodString>;
@@ -89,12 +104,10 @@ export declare const robotImageFacedetectInstructionsWithHiddenFieldsSchema: z.Z
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/facedetect">;
-    provider: z.ZodOptional<z.ZodEnum<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
         aws: "aws";
         gcp: "gcp";
-        replicate: "replicate";
-        fal: "fal";
-        transloadit: "transloadit";
     }>>;
     crop: z.ZodDefault<z.ZodBoolean>;
     crop_padding: z.ZodDefault<z.ZodString>;
@@ -148,12 +161,10 @@ export declare const interpolatableRobotImageFacedetectInstructionsSchema: z.Zod
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/facedetect">;
-    provider: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    provider: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
         aws: "aws";
         gcp: "gcp";
-        replicate: "replicate";
-        fal: "fal";
-        transloadit: "transloadit";
     }>]>>;
     crop: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     crop_padding: z.ZodDefault<z.ZodString>;
@@ -205,12 +216,10 @@ export declare const interpolatableRobotImageFacedetectInstructionsWithHiddenFie
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/facedetect">;
-    provider: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    provider: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
         aws: "aws";
         gcp: "gcp";
-        replicate: "replicate";
-        fal: "fal";
-        transloadit: "transloadit";
     }>]>>;
     crop: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     crop_padding: z.ZodDefault<z.ZodString>;

package/dist/v4/robots/image-facedetect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-facedetect.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-facedetect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,IAAI,EAAE,cAuClB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqGxC,CAAA;AAEX,eAAO,MAAM,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK/D,CAAA;AAEJ,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AACD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEhE,CAAA;AACD,MAAM,MAAM,8CAA8C,GACxD,mDAAmD,CAAA;AAErD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,CAAA;AAC1E,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,oEAAoE,CAC5E,CAAA;AACD,MAAM,MAAM,mEAAmE,GAAG,CAAC,CAAC,KAAK,CACvF,OAAO,oEAAoE,CAC5E,CAAA"}
+{"version":3,"file":"image-facedetect.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-facedetect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,iCAAiC,0DAKpC,CAAA;AAEV,eAAO,MAAM,sCAAsC;;;;;EAA4C,CAAA;AAE/F,eAAO,MAAM,oCAAoC;;;;;;;;kCAUzB,CAAA;AAExB,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AAEjG,eAAO,MAAM,IAAI,EAAE,cAuClB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqGxC,CAAA;AAEX,eAAO,MAAM,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK/D,CAAA;AAEJ,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AACD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEhE,CAAA;AACD,MAAM,MAAM,8CAA8C,GACxD,mDAAmD,CAAA;AAErD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,CAAA;AAC1E,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,oEAAoE,CAC5E,CAAA;AACD,MAAM,MAAM,mEAAmE,GAAG,CAAC,CAAC,KAAK,CACvF,OAAO,oEAAoE,CAC5E,CAAA"}

package/dist/v4/robots/image-facedetect.js

@@ -1,5 +1,23 @@
 import { z } from 'zod/v4';
-import { aiProviderSchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { autoProviderDescription, awsGcpAiProviderSchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+export const imageFacedetectFaceSelectionModes = [
+    'each',
+    'group',
+    'max-confidence',
+    'max-size',
+];
+export const imageFacedetectFaceSelectionModeSchema = z.enum(imageFacedetectFaceSelectionModes);
+export const imageFacedetectFaceCoordinatesSchema = z
+    .object({
+    confidence: z.number().optional(),
+    height: z.number(),
+    width: z.number(),
+    x1: z.number(),
+    x2: z.number().optional(),
+    y1: z.number(),
+    y2: z.number().optional(),
+})
+    .catchall(z.unknown());
 export const meta = {
     bytescount: 1,
     discount_factor: 1,
@@ -56,10 +74,10 @@ This <dfn>Robot</dfn> works well together with [🤖/image/resize](/docs/robots/
 
 </div>
 `),
-    provider: aiProviderSchema.optional().describe(`
-Which AI provider to leverage.
+    provider: awsGcpAiProviderSchema.describe(`
+${autoProviderDescription}
 
-Transloadit outsources this task and abstracts the interface so you can expect the same data structures, but different latencies and information being returned. Different cloud vendors have different areas they shine in, and we recommend to try out and see what yields the best results for your use case.
+Set this to \`"aws"\` or \`"gcp"\` to force a specific provider.
 `),
     crop: z
         .boolean()
@@ -92,7 +110,7 @@ The default value \`"preserve"\` means that the input image format is re-used.
 Specifies the minimum confidence that a detected face must have. Only faces which have a higher confidence value than this threshold will be included in the result.
 `),
     faces: z
-        .union([z.enum(['each', 'group', 'max-confidence', 'max-size']), z.number().int()])
+        .union([imageFacedetectFaceSelectionModeSchema, z.number().int()])
         .default('each')
         .describe(`
 Determines which of the detected faces should be returned. Valid values are:

package/dist/v4/robots/image-generate.d.ts

@@ -99,7 +99,7 @@ export declare const robotImageGenerateInstructionsWithHiddenFieldsSchema: z.Zod
     width: z.ZodOptional<z.ZodNumber>;
     style: z.ZodOptional<z.ZodString>;
     num_outputs: z.ZodOptional<z.ZodNumber>;
-    provider: z.ZodOptional<z.ZodString>;
+    provider: z.ZodDefault<z.ZodString>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, z.core.$strict>;
 export type RobotImageGenerateInstructions = z.infer<typeof robotImageGenerateInstructionsSchema>;
@@ -152,7 +152,7 @@ export declare const interpolatableRobotImageGenerateInstructionsSchema: z.ZodOb
     width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     style: z.ZodOptional<z.ZodString>;
     num_outputs: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    provider: z.ZodOptional<z.ZodString>;
+    provider: z.ZodDefault<z.ZodString>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotImageGenerateInstructions = InterpolatableRobotImageGenerateInstructionsInput;
@@ -205,7 +205,7 @@ export declare const interpolatableRobotImageGenerateInstructionsWithHiddenField
     width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     style: z.ZodOptional<z.ZodString>;
     num_outputs: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    provider: z.ZodOptional<z.ZodString>;
+    provider: z.ZodDefault<z.ZodString>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotImageGenerateInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema>;

package/dist/v4/robots/image-generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-generate.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-generate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cA4ClB,CAAA;AASD,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsEtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}
+{"version":3,"file":"image-generate.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-generate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,IAAI,EAAE,cA4ClB,CAAA;AASD,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsEtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}

package/dist/v4/robots/image-generate.js

@@ -1,5 +1,5 @@
 import { z } from 'zod/v4';
-import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+import { autoProviderDescription, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
     bytescount: 1,
     discount_factor: 1,
@@ -108,7 +108,7 @@ Best practice:
 })
     .strict();
 export const robotImageGenerateInstructionsWithHiddenFieldsSchema = robotImageGenerateInstructionsSchema.extend({
-    provider: z.string().optional().describe('Provider for generating the image.'),
+    provider: z.string().default('auto').describe(autoProviderDescription),
     result: z
         .union([z.literal('debug'), robotImageGenerateInstructionsSchema.shape.result])
         .optional(),

package/dist/v4/robots/image-merge.d.ts

@@ -42,11 +42,16 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     direction: z.ZodDefault<z.ZodEnum<{
         vertical: "vertical";
         horizontal: "horizontal";
+        grid: "grid";
     }>>;
     effect: z.ZodOptional<z.ZodEnum<{
         mosaic: "mosaic";
         "polaroid-stack": "polaroid-stack";
     }>>;
+    columns: z.ZodOptional<z.ZodNumber>;
+    rows: z.ZodOptional<z.ZodNumber>;
+    cell_width: z.ZodOptional<z.ZodNumber>;
+    cell_height: z.ZodOptional<z.ZodNumber>;
     border: z.ZodDefault<z.ZodNumber>;
     background: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
         none: "none";
@@ -67,6 +72,11 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     height: z.ZodOptional<z.ZodNumber>;
     seed: z.ZodOptional<z.ZodNumber>;
     shuffle: z.ZodDefault<z.ZodBoolean>;
+    sort_by: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        basename: "basename";
+        import_order: "import_order";
+    }>>;
     coverage: z.ZodOptional<z.ZodNumber>;
     adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
     quality: z.ZodDefault<z.ZodNumber>;
@@ -111,11 +121,16 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     direction: z.ZodDefault<z.ZodEnum<{
         vertical: "vertical";
         horizontal: "horizontal";
+        grid: "grid";
     }>>;
     effect: z.ZodOptional<z.ZodEnum<{
         mosaic: "mosaic";
         "polaroid-stack": "polaroid-stack";
     }>>;
+    columns: z.ZodOptional<z.ZodNumber>;
+    rows: z.ZodOptional<z.ZodNumber>;
+    cell_width: z.ZodOptional<z.ZodNumber>;
+    cell_height: z.ZodOptional<z.ZodNumber>;
     border: z.ZodDefault<z.ZodNumber>;
     background: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
         none: "none";
@@ -136,6 +151,11 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     height: z.ZodOptional<z.ZodNumber>;
     seed: z.ZodOptional<z.ZodNumber>;
     shuffle: z.ZodDefault<z.ZodBoolean>;
+    sort_by: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        basename: "basename";
+        import_order: "import_order";
+    }>>;
     coverage: z.ZodOptional<z.ZodNumber>;
     adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
     quality: z.ZodDefault<z.ZodNumber>;
@@ -184,11 +204,16 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         vertical: "vertical";
         horizontal: "horizontal";
+        grid: "grid";
     }>]>>;
     effect: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         mosaic: "mosaic";
         "polaroid-stack": "polaroid-stack";
     }>]>>;
+    columns: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    rows: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    cell_width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    cell_height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     border: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         none: "none";
@@ -209,6 +234,11 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     seed: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     shuffle: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    sort_by: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
+        basename: "basename";
+        import_order: "import_order";
+    }>]>>;
     coverage: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     adaptive_filtering: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     quality: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
@@ -255,11 +285,16 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         vertical: "vertical";
         horizontal: "horizontal";
+        grid: "grid";
     }>]>>;
     effect: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         mosaic: "mosaic";
         "polaroid-stack": "polaroid-stack";
     }>]>>;
+    columns: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    rows: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    cell_width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    cell_height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     border: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         none: "none";
@@ -280,6 +315,11 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     seed: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     shuffle: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    sort_by: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
+        basename: "basename";
+        import_order: "import_order";
+    }>]>>;
     coverage: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     adaptive_filtering: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     quality: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;

package/dist/v4/robots/image-merge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgHnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}
+{"version":3,"file":"image-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2JnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}

package/dist/v4/robots/image-merge.js

@@ -1,5 +1,5 @@
 import { z } from 'zod/v4';
-import { color_without_alpha_with_named, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { color_without_alpha_with_named, inputSortBySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
     bytescount: 1,
     discount_factor: 1,
@@ -41,7 +41,7 @@ export const robotImageMergeInstructionsSchema = robotBase
     .merge(robotUse)
     .extend({
     robot: z.literal('/image/merge').describe(`
-The final result will be a spritesheet, with the images displayed horizontally or vertically.
+The final result will be a spritesheet, with the images displayed horizontally, vertically, or in a grid layout.
 
 It's recommended to use this Robot with
 [🤖/image/resize](/docs/robots/image-resize/) so your images are of a
@@ -52,11 +52,13 @@ similar size before merging them.
         .default('png')
         .describe('The output format for the modified image.'),
     direction: z
-        .enum(['horizontal', 'vertical'])
+        .enum(['horizontal', 'vertical', 'grid'])
         .default('horizontal')
         .describe(`
 Specifies the direction which the images are displayed.
 
+Use \`grid\` to arrange inputs left-to-right and top-to-bottom.
+
 Only applies to the default spritesheet layout. Ignored when \`effect\` is set to \`polaroid-stack\` or \`mosaic\`, as those effects use their own layout algorithms.
 `),
     effect: z
@@ -66,6 +68,46 @@ Only applies to the default spritesheet layout. Ignored when \`effect\` is set t
 Applies a styled collage layout instead of a plain horizontal or vertical spritesheet.
 
 Currently supports \`polaroid-stack\`, which renders the inputs as overlapping instant photos on a canvas, and \`mosaic\`, which builds a justified tiled collage.
+`),
+    columns: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe(`
+Number of columns in the grid layout. Only applies when \`direction\` is \`grid\`.
+
+If omitted, columns are calculated automatically from the number of inputs and requested rows.
+`),
+    rows: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe(`
+Number of rows in the grid layout. Only applies when \`direction\` is \`grid\`.
+
+If omitted, rows are calculated automatically from the number of inputs and requested columns.
+`),
+    cell_width: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe(`
+Uniform width for each grid cell in pixels. Only applies when \`direction\` is \`grid\`.
+
+Images are resized to fit within the cell while preserving aspect ratio.
+`),
+    cell_height: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe(`
+Uniform height for each grid cell in pixels. Only applies when \`direction\` is \`grid\`.
+
+Images are resized to fit within the cell while preserving aspect ratio.
 `),
     // TODO: default is not between 1 and 10
     border: z
@@ -121,6 +163,7 @@ Optional deterministic seed used by styled effects such as \`polaroid-stack\` an
         .describe(`
 Whether styled effects such as \`polaroid-stack\` and \`mosaic\` may shuffle the input order before laying out the canvas.
 `),
+    sort_by: inputSortBySchema,
     coverage: z
         .number()
         .min(0.5)

package/dist/v4/robots/image-ocr.d.ts

@@ -34,21 +34,19 @@ export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/ocr">;
-    provider: z.ZodEnum<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
         aws: "aws";
         gcp: "gcp";
-        replicate: "replicate";
-        fal: "fal";
-        transloadit: "transloadit";
-    }>;
+    }>>;
     granularity: z.ZodDefault<z.ZodEnum<{
         full: "full";
         list: "list";
     }>>;
     format: z.ZodDefault<z.ZodEnum<{
         meta: "meta";
-        text: "text";
         json: "json";
+        text: "text";
     }>>;
 }, z.core.$strict>;
 export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObject<{
@@ -83,21 +81,19 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObjec
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/ocr">;
-    provider: z.ZodEnum<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
         aws: "aws";
         gcp: "gcp";
-        replicate: "replicate";
-        fal: "fal";
-        transloadit: "transloadit";
-    }>;
+    }>>;
     granularity: z.ZodDefault<z.ZodEnum<{
         full: "full";
         list: "list";
     }>>;
     format: z.ZodDefault<z.ZodEnum<{
         meta: "meta";
-        text: "text";
         json: "json";
+        text: "text";
     }>>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
 }, z.core.$strict>;
@@ -136,21 +132,19 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/ocr">;
-    provider: z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    provider: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
         aws: "aws";
         gcp: "gcp";
-        replicate: "replicate";
-        fal: "fal";
-        transloadit: "transloadit";
-    }>]>;
+    }>]>>;
     granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         full: "full";
         list: "list";
     }>]>>;
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         meta: "meta";
-        text: "text";
         json: "json";
+        text: "text";
     }>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotImageOcrInstructions = InterpolatableRobotImageOcrInstructionsInput;
@@ -187,21 +181,19 @@ export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSche
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/ocr">;
-    provider: z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    provider: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
         aws: "aws";
         gcp: "gcp";
-        replicate: "replicate";
-        fal: "fal";
-        transloadit: "transloadit";
-    }>]>;
+    }>]>>;
     granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         full: "full";
         list: "list";
     }>]>>;
     format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         meta: "meta";
-        text: "text";
         json: "json";
+        text: "text";
     }>]>>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;

package/dist/v4/robots/image-ocr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-ocr.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-ocr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,IAAI,EAAE,cAwClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGxD,CAAA;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,4CAA4C,CAAA;AAElG,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzE,CAAA;AACD,MAAM,MAAM,uDAAuD,GAAG,CAAC,CAAC,KAAK,CAC3E,OAAO,6DAA6D,CACrE,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,6DAA6D,CACrE,CAAA"}
+{"version":3,"file":"image-ocr.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-ocr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAW1B,eAAO,MAAM,IAAI,EAAE,cAwClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGxD,CAAA;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,4CAA4C,CAAA;AAElG,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzE,CAAA;AACD,MAAM,MAAM,uDAAuD,GAAG,CAAC,CAAC,KAAK,CAC3E,OAAO,6DAA6D,CACrE,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,6DAA6D,CACrE,CAAA"}

package/dist/v4/robots/image-ocr.js

@@ -1,5 +1,5 @@
 import { z } from 'zod/v4';
-import { aiProviderSchema, granularitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { autoProviderDescription, awsGcpAiProviderSchema, granularitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
     bytescount: 1,
     discount_factor: 1,
@@ -49,10 +49,10 @@ With this <dfn>Robot</dfn> you can detect and extract text from images using opt
 
 For example, you can use the results to obtain the content of traffic signs, name tags, package labels and many more. You can also pass the text down to other <dfn>Robots</dfn> to filter images that contain (or do not contain) certain phrases. For images of dense documents, results may vary and be less accurate than for small pieces of text in photos.
 `),
-    provider: aiProviderSchema.describe(`
-Which AI provider to leverage.
+    provider: awsGcpAiProviderSchema.describe(`
+${autoProviderDescription}
 
-Transloadit outsources this task and abstracts the interface so you can expect the same data structures, but different latencies and information being returned. Different cloud vendors have different areas they shine in, and we recommend to try out and see what yields the best results for your use case.
+Set this to \`"aws"\` or \`"gcp"\` to force a specific provider.
 
 AWS supports detection for the following languages: English, Arabic, Russian, German, French, Italian, Portuguese and Spanish. GCP allows for a wider range of languages, with varying levels of support which can be found on the [official documentation](https://cloud.google.com/vision/docs/languages/).
 `),