@transloadit/node 4.11.0 → 4.12.0

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

@@ -2,15 +2,28 @@ import type { RobotMetaInput } from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
-import { interpolateRobot, robotBase, robotUse } from './_instructions-primitives.ts'
+import {
+  autoProviderDescription,
+  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.
 
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonValue[]
+  | { [key: string]: JsonValue }
+
 // Define JSONValue schema for proper type matching with AI SDK
-const jsonValueSchema: z.ZodType = z.lazy(() =>
+const jsonValueSchema: z.ZodType<JsonValue> = z.lazy(() =>
   z.union([
     z.string(),
     z.number(),
@@ -21,74 +34,323 @@ const jsonValueSchema: z.ZodType = z.lazy(() =>
   ]),
 )
 
-// Define provider metadata schema to match the AI SDK v5
+// Define provider options schema to match the AI SDK.
 const providerMetadataSchema = z.record(z.record(jsonValueSchema)).optional()
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function withCurrentProviderOptions(value: Record<string, unknown>): Record<string, unknown> {
+  const { experimental_providerMetadata, ...rest } = value
+  const providerOptions = value.providerOptions ?? experimental_providerMetadata
+  return providerOptions === undefined ? rest : { ...rest, providerOptions }
+}
+
+function legacyToolOutput(
+  result: unknown,
+  isError: boolean,
+  experimentalContent: unknown,
+): unknown {
+  if (!isError && Array.isArray(experimentalContent)) {
+    const content = experimentalContent.flatMap((part): unknown[] => {
+      if (!isRecord(part)) {
+        return []
+      }
+      if (part.type === 'text' && typeof part.text === 'string') {
+        return [{ type: 'text', text: part.text }]
+      }
+      if (part.type === 'image' && typeof part.data === 'string') {
+        return [
+          {
+            type: 'image-data',
+            data: part.data,
+            mediaType: typeof part.mimeType === 'string' ? part.mimeType : 'image',
+          },
+        ]
+      }
+      if (
+        part.type === 'media' &&
+        typeof part.data === 'string' &&
+        typeof part.mediaType === 'string'
+      ) {
+        return [{ type: 'file-data', data: part.data, mediaType: part.mediaType }]
+      }
+      return []
+    })
+    if (content.length === experimentalContent.length) {
+      return { type: 'content', value: content }
+    }
+  }
+
+  let parsed: ReturnType<typeof jsonValueSchema.safeParse> | undefined
+  try {
+    // Zod's recursive JSON schema overflows before returning a failed parse for circular values.
+    parsed = jsonValueSchema.safeParse(result)
+  } catch {
+    parsed = undefined
+  }
+  if (parsed?.success) {
+    return { type: isError ? 'error-json' : 'json', value: parsed.data }
+  }
+  return { type: isError ? 'error-text' : 'text', value: stringifyLegacyToolResult(result) }
+}
+
+function stringifyLegacyToolResult(result: unknown): string {
+  try {
+    const serialized = JSON.stringify(result)
+    if (serialized !== undefined) {
+      return serialized
+    }
+  } catch {
+    // Fall back to the platform string representation for circular or unsupported values.
+  }
+  return String(result)
+}
+
+function normalizeMessagePart(value: unknown): unknown {
+  if (!isRecord(value)) {
+    return value
+  }
+
+  const normalized = withCurrentProviderOptions(value)
+  if (normalized.type === 'image' && !('mediaType' in normalized) && 'mimeType' in normalized) {
+    const { mimeType, ...rest } = normalized
+    return { ...rest, mediaType: mimeType }
+  }
+  if (
+    normalized.type === 'media' &&
+    typeof normalized.data === 'string' &&
+    typeof normalized.mediaType === 'string'
+  ) {
+    const { data, mediaType, type: _type, ...rest } = normalized
+    return { ...rest, type: 'file', data: { type: 'data', data }, mediaType }
+  }
+  if (normalized.type === 'tool-call' && !('input' in normalized) && 'args' in normalized) {
+    const { args, ...rest } = normalized
+    return { ...rest, input: args }
+  }
+  if (normalized.type === 'tool-result' && 'output' in normalized) {
+    const output = normalized.output
+    if (isRecord(output) && output.type === 'content' && Array.isArray(output.value)) {
+      return {
+        ...normalized,
+        output: {
+          ...output,
+          value: output.value.map((part) => {
+            if (
+              isRecord(part) &&
+              part.type === 'media' &&
+              typeof part.data === 'string' &&
+              typeof part.mediaType === 'string'
+            ) {
+              return { type: 'file-data', data: part.data, mediaType: part.mediaType }
+            }
+            return part
+          }),
+        },
+      }
+    }
+  }
+  if (normalized.type === 'tool-result' && !('output' in normalized)) {
+    const { experimental_content: experimentalContent, isError, result, ...rest } = normalized
+    return {
+      ...rest,
+      output: legacyToolOutput(result, isError === true, experimentalContent),
+    }
+  }
+  return normalized
+}
+
+function normalizeMessage(value: unknown): unknown {
+  if (!isRecord(value)) {
+    return value
+  }
+  const normalized = withCurrentProviderOptions(value)
+  return Array.isArray(normalized.content)
+    ? { ...normalized, content: normalized.content.map(normalizeMessagePart) }
+    : normalized
+}
+
+const inlineDataSchema = z.union([z.string(), z.instanceof(Uint8Array), z.instanceof(ArrayBuffer)])
+const providerReferenceSchema = z.record(z.string(), z.string())
+const taggedFileDataSchema = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('data'), data: inlineDataSchema }),
+  z.object({ type: z.literal('url'), url: z.instanceof(URL) }),
+  z.object({ type: z.literal('reference'), reference: providerReferenceSchema }),
+  z.object({ type: z.literal('text'), text: z.string() }),
+])
+const taggedReasoningFileDataSchema = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('data'), data: inlineDataSchema }),
+  z.object({ type: z.literal('url'), url: z.instanceof(URL) }),
+])
+
 const textPartSchema = z.object({
   type: z.literal('text'),
   text: z.string(),
-  experimental_providerMetadata: providerMetadataSchema,
+  providerOptions: 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,
+  image: z.union([inlineDataSchema, z.instanceof(URL), providerReferenceSchema]),
+  mediaType: z.string().optional(),
+  providerOptions: 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.
+    taggedFileDataSchema,
+    inlineDataSchema,
     z.instanceof(URL),
+    providerReferenceSchema,
   ]),
+  filename: z.string().optional(),
   mediaType: z.string(),
-  experimental_providerMetadata: providerMetadataSchema,
+  providerOptions: providerMetadataSchema,
+})
+const reasoningPartSchema = z.object({
+  type: z.literal('reasoning'),
+  text: z.string(),
+  providerOptions: providerMetadataSchema,
 })
-const toolCallPartSchema = z.object({
+function isCustomKind(value: string): value is `${string}.${string}` {
+  return value.includes('.')
+}
+const customPartSchema = z.object({
+  type: z.literal('custom'),
+  kind: z.string().refine(isCustomKind),
+  providerOptions: providerMetadataSchema,
+})
+const reasoningFilePartSchema = z.object({
+  type: z.literal('reasoning-file'),
+  data: z.union([taggedReasoningFileDataSchema, inlineDataSchema, z.instanceof(URL)]),
+  mediaType: z.string(),
+  providerOptions: providerMetadataSchema,
+})
+const toolCallPartBaseSchema = z.object({
   type: z.literal('tool-call'),
   toolCallId: z.string(),
   toolName: z.string(),
-  args: z.record(jsonValueSchema),
-  experimental_providerMetadata: providerMetadataSchema,
+  input: z.unknown(),
+  providerOptions: providerMetadataSchema,
+  providerExecuted: z.boolean().optional(),
 })
-const toolResultPartSchema = z.object({
-  type: z.literal('tool-result'),
-  toolCallId: z.string(),
-  toolName: z.string(),
-  result: z.unknown(),
-  experimental_content: z
-    .array(
+type ToolCallPart = Omit<z.infer<typeof toolCallPartBaseSchema>, 'input'> & { input: unknown }
+const toolCallPartSchema = toolCallPartBaseSchema.transform(
+  (part): ToolCallPart => ({ ...part, input: part.input }),
+)
+const toolOutputSchema = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('text'), value: z.string(), providerOptions: providerMetadataSchema }),
+  z.object({
+    type: z.literal('json'),
+    value: jsonValueSchema,
+    providerOptions: providerMetadataSchema,
+  }),
+  z.object({
+    type: z.literal('execution-denied'),
+    reason: z.string().optional(),
+    providerOptions: providerMetadataSchema,
+  }),
+  z.object({
+    type: z.literal('error-text'),
+    value: z.string(),
+    providerOptions: providerMetadataSchema,
+  }),
+  z.object({
+    type: z.literal('error-json'),
+    value: jsonValueSchema,
+    providerOptions: providerMetadataSchema,
+  }),
+  z.object({
+    type: z.literal('content'),
+    value: z.array(
       z.union([
         z.object({
           type: z.literal('text'),
           text: z.string(),
+          providerOptions: providerMetadataSchema,
+        }),
+        z.object({
+          type: z.literal('file'),
+          data: taggedFileDataSchema,
+          mediaType: z.string(),
+          filename: z.string().optional(),
+          providerOptions: providerMetadataSchema,
         }),
         z.object({
-          type: z.literal('image'),
+          type: z.literal('file-data'),
           data: z.string(),
-          mimeType: z.string().optional(),
+          mediaType: z.string(),
+          filename: z.string().optional(),
+          providerOptions: providerMetadataSchema,
+        }),
+        z.object({
+          type: z.literal('file-url'),
+          url: z.string(),
+          mediaType: z.string().optional(),
+          providerOptions: providerMetadataSchema,
+        }),
+        z.object({
+          type: z.literal('file-id'),
+          fileId: z.union([z.string(), providerReferenceSchema]),
+          providerOptions: providerMetadataSchema,
+        }),
+        z.object({
+          type: z.literal('file-reference'),
+          providerReference: providerReferenceSchema,
+          providerOptions: providerMetadataSchema,
         }),
+        z.object({
+          type: z.literal('image-data'),
+          data: z.string(),
+          mediaType: z.string(),
+          providerOptions: providerMetadataSchema,
+        }),
+        z.object({
+          type: z.literal('image-url'),
+          url: z.string(),
+          providerOptions: providerMetadataSchema,
+        }),
+        z.object({
+          type: z.literal('image-file-id'),
+          fileId: z.union([z.string(), providerReferenceSchema]),
+          providerOptions: providerMetadataSchema,
+        }),
+        z.object({
+          type: z.literal('image-file-reference'),
+          providerReference: providerReferenceSchema,
+          providerOptions: providerMetadataSchema,
+        }),
+        z.object({ type: z.literal('custom'), providerOptions: providerMetadataSchema }),
       ]),
-    )
-    .optional(),
-  isError: z.boolean().optional(),
-  experimental_providerMetadata: providerMetadataSchema,
+    ),
+  }),
+])
+const toolResultPartSchema = z.object({
+  type: z.literal('tool-result'),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  output: toolOutputSchema,
+  providerOptions: providerMetadataSchema,
+})
+const toolApprovalRequestSchema = z.object({
+  type: z.literal('tool-approval-request'),
+  approvalId: z.string(),
+  toolCallId: z.string(),
+  isAutomatic: z.boolean().optional(),
+  signature: z.string().optional(),
+})
+const toolApprovalResponseSchema = z.object({
+  type: z.literal('tool-approval-response'),
+  approvalId: z.string(),
+  approved: z.boolean(),
+  reason: z.string().optional(),
+  providerExecuted: z.boolean().optional(),
 })
 const coreSystemMessageSchema = z.object({
   role: z.literal('system'),
   content: z.string(),
-  experimental_providerMetadata: providerMetadataSchema,
+  providerOptions: providerMetadataSchema,
 })
 const coreUserMessageSchema = z.object({
   role: z.literal('user'),
@@ -96,24 +358,141 @@ const coreUserMessageSchema = z.object({
     z.string(),
     z.array(z.union([textPartSchema, imagePartSchema, filePartSchema])),
   ]),
-  experimental_providerMetadata: providerMetadataSchema,
+  providerOptions: providerMetadataSchema,
 })
 const coreAssistantMessageSchema = z.object({
   role: z.literal('assistant'),
-  content: z.union([z.string(), z.array(z.union([textPartSchema, toolCallPartSchema]))]),
-  experimental_providerMetadata: providerMetadataSchema,
+  content: z.union([
+    z.string(),
+    z.array(
+      z.union([
+        textPartSchema,
+        customPartSchema,
+        filePartSchema,
+        reasoningPartSchema,
+        reasoningFilePartSchema,
+        toolCallPartSchema,
+        toolResultPartSchema,
+        toolApprovalRequestSchema,
+      ]),
+    ),
+  ]),
+  providerOptions: providerMetadataSchema,
 })
 const coreToolMessageSchema = z.object({
   role: z.literal('tool'),
-  content: z.array(toolResultPartSchema),
-  experimental_providerMetadata: providerMetadataSchema,
+  content: z.array(z.union([toolResultPartSchema, toolApprovalResponseSchema])),
+  providerOptions: providerMetadataSchema,
 })
-const coreMessageSchema = z.discriminatedUnion('role', [
+const coreMessageOutputSchema = z.discriminatedUnion('role', [
   coreSystemMessageSchema,
   coreUserMessageSchema,
   coreAssistantMessageSchema,
   coreToolMessageSchema,
 ])
+const coreMessageSchema = z.preprocess(normalizeMessage, coreMessageOutputSchema)
+
+type ProviderMetadata = NonNullable<z.output<typeof providerMetadataSchema>>
+type CompatibleProviderOptions<Part extends { providerOptions?: ProviderMetadata }> = Omit<
+  Part,
+  'providerOptions'
+> & {
+  providerOptions?: ProviderMetadata
+  experimental_providerMetadata?: ProviderMetadata
+}
+type MessageProviderOptions = {
+  providerOptions?: ProviderMetadata
+  experimental_providerMetadata?: ProviderMetadata
+}
+
+type TextPartInput = CompatibleProviderOptions<z.output<typeof textPartSchema>>
+type ImagePartInput = CompatibleProviderOptions<z.output<typeof imagePartSchema>>
+type LegacyImagePartInput = CompatibleProviderOptions<
+  Omit<z.output<typeof imagePartSchema>, 'mediaType'> & { mimeType?: string }
+>
+type FilePartInput = CompatibleProviderOptions<z.output<typeof filePartSchema>>
+type CustomPartInput = CompatibleProviderOptions<z.output<typeof customPartSchema>>
+type ReasoningPartInput = CompatibleProviderOptions<z.output<typeof reasoningPartSchema>>
+type ReasoningFilePartInput = CompatibleProviderOptions<z.output<typeof reasoningFilePartSchema>>
+type ToolCallPartInput = CompatibleProviderOptions<z.output<typeof toolCallPartSchema>>
+type LegacyToolCallPartInput = Omit<ToolCallPartInput, 'input'> & { args: unknown }
+type ToolResultPartInput = CompatibleProviderOptions<z.output<typeof toolResultPartSchema>>
+
+type LegacyTextToolContentPart = { type: 'text'; text: string }
+type LegacyImageToolContentPart = { type: 'image'; data: string; mimeType?: string }
+type LegacyMediaToolContentPart = { type: 'media'; data: string; mediaType: string }
+type LegacyToolContentPart =
+  | LegacyTextToolContentPart
+  | LegacyImageToolContentPart
+  | LegacyMediaToolContentPart
+type CurrentToolContentPart = Extract<
+  z.output<typeof toolOutputSchema>,
+  { type: 'content' }
+>['value'][number]
+type LegacyToolResultPartInput = {
+  type: 'tool-result'
+  toolCallId: string
+  toolName: string
+  output?:
+    | Exclude<z.output<typeof toolOutputSchema>, { type: 'content' }>
+    | { type: 'content'; value: Array<CurrentToolContentPart | LegacyToolContentPart> }
+  result?: unknown
+  isError?: boolean
+  experimental_content?: LegacyToolContentPart[]
+} & MessageProviderOptions
+type LegacyMediaMessagePartInput = LegacyMediaToolContentPart & MessageProviderOptions
+
+type CoreSystemMessageInput = {
+  role: 'system'
+  content: string
+} & MessageProviderOptions
+type CoreUserMessageInput = {
+  role: 'user'
+  content:
+    | string
+    | Array<
+        | TextPartInput
+        | ImagePartInput
+        | LegacyImagePartInput
+        | FilePartInput
+        | LegacyMediaMessagePartInput
+      >
+} & MessageProviderOptions
+type CoreAssistantMessageInput = {
+  role: 'assistant'
+  content:
+    | string
+    | Array<
+        | TextPartInput
+        | CustomPartInput
+        | FilePartInput
+        | ReasoningPartInput
+        | ReasoningFilePartInput
+        | ToolCallPartInput
+        | LegacyToolCallPartInput
+        | ToolResultPartInput
+        | LegacyToolResultPartInput
+        | z.output<typeof toolApprovalRequestSchema>
+      >
+} & MessageProviderOptions
+type CoreToolMessageInput = {
+  role: 'tool'
+  content: Array<
+    ToolResultPartInput | LegacyToolResultPartInput | z.output<typeof toolApprovalResponseSchema>
+  >
+} & MessageProviderOptions
+
+export type CoreMessageInput =
+  | z.output<typeof coreMessageOutputSchema>
+  | CoreSystemMessageInput
+  | CoreUserMessageInput
+  | CoreAssistantMessageInput
+  | CoreToolMessageInput
+
+type WithTypedMessages<Instructions extends { messages: unknown }> = Omit<
+  Instructions,
+  'messages'
+> & { messages: string | CoreMessageInput[] }
 
 export const meta: RobotMetaInput = {
   name: 'AiChatRobot',
@@ -154,17 +533,26 @@ export const meta: RobotMetaInput = {
 }
 
 /**
- * Model capabilities for /ai/chat. This centralizes which models support which input types.
+ * Transloadit's supported /ai/chat models and their input capabilities.
+ * This is intentionally not a complete vendor catalog: add models only after runtime behavior,
+ * pricing, and file handling have been reviewed.
  * Key format: 'vendor/model'
  */
 export const MODEL_CAPABILITIES: Record<string, { pdf: boolean; image: boolean }> = {
+  'anthropic/claude-sonnet-4-6': { pdf: true, image: true },
   'anthropic/claude-4-sonnet-20250514': { pdf: true, image: true },
+  'anthropic/claude-sonnet-4-20250514': { pdf: true, image: true },
+  'anthropic/claude-opus-4-8': { pdf: true, image: true },
+  'anthropic/claude-opus-5': { pdf: true, image: true },
   'anthropic/claude-4-opus-20250514': { pdf: true, image: true },
+  'anthropic/claude-opus-4-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 },
-  'anthropic/claude-opus-4-8': { pdf: true, image: true },
+  'anthropic/claude-fable-5': { pdf: true, image: true },
+  'anthropic/claude-fable-5-1': { pdf: true, image: true },
+  'anthropic/claude-sonnet-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 },
@@ -176,6 +564,8 @@ export const MODEL_CAPABILITIES: Record<string, { pdf: boolean; image: boolean }
   '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.6-sol': { pdf: false, image: true },
+  'openai/gpt-6-astra': { 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 },
@@ -183,10 +573,8 @@ export const MODEL_CAPABILITIES: Record<string, { pdf: boolean; image: boolean }
   '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' satisfies keyof typeof MODEL_CAPABILITIES
+/** Default /ai/chat model for `auto` or omitted selections; keep aligned with the API backend. */
+export const AI_CHAT_DEFAULT_MODEL = 'openai/gpt-6-astra' satisfies keyof typeof MODEL_CAPABILITIES
 
 const supportedModelsList = Object.keys(MODEL_CAPABILITIES)
 
@@ -226,19 +614,19 @@ export const robotAiChatInstructionsSchema = robotBase
       .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.',
+        '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, GPT-6, 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. When using your own AI provider keys, Transloadit charges a 10% markup (minimum $0.0005 per request).',
+        'Names of template credentials to make available to the robot. When using your own AI provider keys, Transloadit charges a 30% markup (minimum $0.0005 per request).',
       ),
     test_credentials: z
       .boolean()
       .optional()
       .describe(
-        'Use Transloadit-provided credentials for testing. Usage is billed at provider cost plus a 10% markup (minimum $0.0005 per request).',
+        'Use Transloadit-provided credentials for testing. Usage is billed at provider cost plus a 30% markup (minimum $0.0005 per request).',
       ),
     mcp_servers: z
       .array(
@@ -266,9 +654,9 @@ export const robotAiChatInstructionsWithHiddenFieldsSchema = robotAiChatInstruct
   result: z.union([z.literal('debug'), robotAiChatInstructionsSchema.shape.result]),
   provider: z
     .string()
-    .optional()
+    .default('auto')
     .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. ',
+      `${autoProviderDescription} This is a hidden placeholder for future model routing flexibility.`,
     ),
   // These are listed here because we don't have these properties in the public documentation.
   // They should set these keys using template credentials.
@@ -283,13 +671,16 @@ export const robotAiChatInstructionsWithHiddenFieldsSchema = robotAiChatInstruct
 })
 
 export type RobotAiChatInstructions = z.infer<typeof robotAiChatInstructionsSchema>
+export type RobotAiChatInstructionsInput = WithTypedMessages<
+  z.input<typeof robotAiChatInstructionsSchema>
+>
 
 export type RobotAiChatInstructionsWithHiddenFields = z.infer<
   typeof robotAiChatInstructionsWithHiddenFieldsSchema
 >
 
-export type RobotAiChatInstructionsWithHiddenFieldsInput = z.input<
-  typeof robotAiChatInstructionsWithHiddenFieldsSchema
+export type RobotAiChatInstructionsWithHiddenFieldsInput = WithTypedMessages<
+  z.input<typeof robotAiChatInstructionsWithHiddenFieldsSchema>
 >
 
 export const interpolatableRobotAiChatInstructionsSchema = interpolateRobot(
@@ -298,8 +689,8 @@ export const interpolatableRobotAiChatInstructionsSchema = interpolateRobot(
 export type InterpolatableRobotAiChatInstructions = z.infer<
   typeof interpolatableRobotAiChatInstructionsSchema
 >
-export type InterpolatableRobotAiChatInstructionsInput = z.input<
-  typeof interpolatableRobotAiChatInstructionsSchema
+export type InterpolatableRobotAiChatInstructionsInput = WithTypedMessages<
+  z.input<typeof interpolatableRobotAiChatInstructionsSchema>
 >
 
 export const interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema = interpolateRobot(
@@ -308,6 +699,6 @@ export const interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema = inter
 export type InterpolatableRobotAiChatInstructionsWithHiddenFields = z.infer<
   typeof interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema
 >
-export type InterpolatableRobotAiChatInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema
+export type InterpolatableRobotAiChatInstructionsWithHiddenFieldsInput = WithTypedMessages<
+  z.input<typeof interpolatableRobotAiChatInstructionsWithHiddenFieldsSchema>
 >

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

@@ -43,6 +43,7 @@ export const meta: RobotMetaInput = {
   queueSlotCount: 20,
   isAllowedForUrlTransform: true,
   trackOutputFileSize: true,
+  applyCommunityPlanMediaTrim: true,
   isInternal: false,
   removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
   stage: 'ga',

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

@@ -5,6 +5,7 @@ import { z } from 'zod'
 import { stackVersions } from '../stackVersions.ts'
 import {
   bitrateSchema,
+  inputSortBySchema,
   interpolateRobot,
   robotBase,
   robotFFmpegAudio,
@@ -64,6 +65,7 @@ export const meta: RobotMetaInput = {
   queueSlotCount: 20,
   isAllowedForUrlTransform: true,
   trackOutputFileSize: true,
+  applyCommunityPlanMediaTrim: true,
   isInternal: false,
   removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
   stage: 'ga',
@@ -104,6 +106,7 @@ The duration of the crossfade is controlled by the \`audio_fade_seconds\` parame
 
 Note: This parameter requires at least 2 audio files to concatenate and only works with audio files, not video files.
 `),
+    sort_by: inputSortBySchema,
   })
   .strict()