@transloadit/zod 4.1.5 → 4.1.6

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

@@ -0,0 +1,215 @@
+import { z } from 'zod/v4';
+import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+// 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.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema),
+]));
+// Define provider metadata schema to match the AI SDK v5
+const providerMetadataSchema = z.record(z.string(), z.record(z.string(), 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(z.string(), jsonValueSchema),
+    experimental_providerMetadata: providerMetadataSchema,
+});
+const toolResultPartSchema = z.object({
+    type: z.literal('tool-result'),
+    toolCallId: z.string(),
+    toolName: z.string(),
+    result: z.unknown().optional(),
+    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 = {
+    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',
+};
+/**
+ * Model capabilities for /ai/chat. This centralizes which models support which input types.
+ * Key format: 'vendor/model'
+ */
+export const MODEL_CAPABILITIES = {
+    'anthropic/claude-4-sonnet-20250514': { pdf: true, image: true },
+    '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 },
+    '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 },
+    'openai/gpt-5.2': { pdf: false, image: true },
+    '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 },
+    'google/gemini-2.5-pro': { pdf: true, image: true },
+    'moonshot/kimi-k2': { pdf: false, image: false },
+};
+const supportedModelsList = Object.keys(MODEL_CAPABILITIES);
+export const vendorModelSchema = z
+    .string()
+    .regex(/^[a-z]+\/[a-z0-9.-]+$/, 'Must be in format "vendor/model"')
+    .refine((val) => Object.hasOwn(MODEL_CAPABILITIES, val), {
+    message: `Invalid vendor/model combination. Supported: ${supportedModelsList.join(', ')}`,
+});
+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.'),
+    test_credentials: z
+        .boolean()
+        .optional()
+        .describe('Use Transloadit-provided credentials for testing.'),
+    mcp_servers: z
+        .array(z.object({
+        type: z.enum(['sse', 'http']),
+        url: z.string(),
+        headers: z.record(z.string(), 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 const interpolatableRobotAiChatInstructionsSchema = interpolateRobot(robotAiChatInstructionsSchema);
+export const interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema = interpolateRobot(robotAiChatInstructionsWithHiddenFieldsSchema);

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

@@ -0,0 +1,33 @@
+import { z } from 'zod/v4';
+import type { RobotMetaInput } from './_instructions-primitives.ts';
+export declare const meta: RobotMetaInput;
+export declare const robotAssemblySavejsonInstructionsSchema: z.ZodObject<{
+    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<{
+        batch: "batch";
+    }>>;
+    force_accept: z.ZodDefault<z.ZodBoolean>;
+    ignore_errors: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>>;
+    robot: z.ZodLiteral<"/assembly/savejson">;
+}, z.core.$strict>;
+export type RobotAssemblySavejsonInstructions = z.infer<typeof robotAssemblySavejsonInstructionsSchema>;
+export declare const interpolatableRobotAssemblySavejsonInstructionsSchema: z.ZodObject<{
+    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<{
+        batch: "batch";
+    }>]>>;
+    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
+    robot: z.ZodLiteral<"/assembly/savejson">;
+}, z.core.$strict>;
+export type InterpolatableRobotAssemblySavejsonInstructions = InterpolatableRobotAssemblySavejsonInstructionsInput;
+export type InterpolatableRobotAssemblySavejsonInstructionsInput = z.input<typeof interpolatableRobotAssemblySavejsonInstructionsSchema>;
+//# sourceMappingURL=assembly-savejson.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,21 @@
+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 = {
+    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 const interpolatableRobotAssemblySavejsonInstructionsSchema = interpolateRobot(robotAssemblySavejsonInstructionsSchema);