@mux/ai 0.30.0 → 0.32.0

package/dist/workflows/index.js

@@ -4,7 +4,7 @@ import dedent2 from "dedent";
 import { z as z3 } from "zod";
 
 // src/lib/content-policy-error.ts
-import { APICallError, NoObjectGeneratedError, RetryError } from "ai";
+import { APICallError as APICallError2, NoObjectGeneratedError, RetryError } from "ai";
 import { z as z2 } from "zod";
 
 // src/lib/prompt-fragments.ts
@@ -79,6 +79,43 @@ var EnvSchema = z.object({
   MUX_AI_EVAL_MODELS: optionalString("Comma-separated eval model pairs.", "Comma-separated provider:model pairs (e.g. 'openai:gpt-5.6-luna,anthropic:claude-sonnet-4-5,google:gemini-3-flash-preview')"),
   // AI Providers
   OPENAI_API_KEY: optionalString("OpenAI API key for OpenAI-backed workflows.", "OpenAI API key"),
+  BASETEN_API_KEY: optionalString("Baseten API key for Baseten-backed workflows.", "Baseten API key"),
+  BASETEN_URL: optionalString(
+    "Optional Baseten language endpoint URL: a dedicated deployment's /sync/v1 URL (such as https://model-{MODEL_ID}.api.baseten.co/environments/production/sync/v1) or a shared OpenAI-compatible base URL. Omit to use Baseten Model APIs.",
+    "Baseten URL"
+  ),
+  BASETEN_EMBEDDING_URL: optionalString(
+    "Baseten dedicated embedding deployment URL, such as https://model-{MODEL_ID}.api.baseten.co/environments/production/sync. Required for Baseten embeddings.",
+    "Baseten embedding URL"
+  ),
+  BASETEN_MODEL: optionalString(
+    "Default Baseten language model identifier used when provider='baseten' and no explicit model is passed.",
+    "Baseten model"
+  ),
+  BASETEN_EMBEDDING_MODEL: optionalString(
+    "Default Baseten embedding model identifier used when provider='baseten' and no explicit model is passed.",
+    "Baseten embedding model"
+  ),
+  OPENAI_COMPATIBLE_API_KEY: optionalString(
+    "Optional API key for OpenAI-compatible endpoints. Some local or self-hosted endpoints do not require one.",
+    "OpenAI-compatible API key"
+  ),
+  OPENAI_COMPATIBLE_BASE_URL: optionalString(
+    "Base URL of an OpenAI-compatible API, such as https://my-endpoint.example.com/v1.",
+    "OpenAI-compatible base URL"
+  ),
+  OPENAI_COMPATIBLE_EMBEDDING_BASE_URL: optionalString(
+    "Optional embedding-specific OpenAI-compatible base URL. Falls back to OPENAI_COMPATIBLE_BASE_URL.",
+    "OpenAI-compatible embedding base URL"
+  ),
+  OPENAI_COMPATIBLE_MODEL: optionalString(
+    "Default language model identifier used when provider='openai-compatible' and no explicit model is passed.",
+    "OpenAI-compatible model"
+  ),
+  OPENAI_COMPATIBLE_EMBEDDING_MODEL: optionalString(
+    "Default embedding model identifier used when provider='openai-compatible' and no explicit model is passed.",
+    "OpenAI-compatible embedding model"
+  ),
   ANTHROPIC_API_KEY: optionalString("Anthropic API key for Claude-backed workflows.", "Anthropic API key"),
   GOOGLE_GENERATIVE_AI_API_KEY: optionalString("Google Generative AI API key for Gemini-backed workflows.", "Google Generative AI API key"),
   ELEVENLABS_API_KEY: optionalString("ElevenLabs API key for audio translation.", "ElevenLabs API key"),
@@ -507,6 +544,67 @@ function wrapError(error, message) {
   throw wrapped;
 }
 
+// src/lib/retry.ts
+import { APICallError, DownloadError, NoOutputGeneratedError } from "ai";
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 3,
+  baseDelay: 2e3,
+  maxDelay: 1e4
+};
+function defaultShouldRetry(error, _attempt) {
+  if (error.message.includes("Timeout while downloading")) {
+    return true;
+  }
+  if (NoOutputGeneratedError.isInstance(error) || error.name === "AI_NoOutputGeneratedError" || error.name === "AI_NoObjectGeneratedError") {
+    return true;
+  }
+  if (APICallError.isInstance(error) || error.name === "AI_APICallError") {
+    const apiError = error;
+    if (typeof apiError.isRetryable === "boolean") {
+      return apiError.isRetryable;
+    }
+    return apiError.statusCode === 408 || apiError.statusCode === 409 || apiError.statusCode === 429 || apiError.statusCode !== void 0 && apiError.statusCode >= 500;
+  }
+  const isDownloadError = DownloadError.isInstance(error);
+  const isSerializedDownloadError = error.name === "AI_DownloadError";
+  if (!isDownloadError && !isSerializedDownloadError) {
+    return false;
+  }
+  const statusCode = error.statusCode;
+  return statusCode === void 0 || statusCode === 408 || statusCode === 425 || statusCode === 429 || statusCode >= 500;
+}
+function calculateDelay(attempt, baseDelay, maxDelay) {
+  const exponentialDelay = baseDelay * 2 ** (attempt - 1);
+  const delayWithJitter = exponentialDelay * (0.5 + Math.random() * 0.5);
+  return Math.min(delayWithJitter, maxDelay);
+}
+async function withRetry(fn, {
+  maxRetries = DEFAULT_RETRY_OPTIONS.maxRetries,
+  baseDelay = DEFAULT_RETRY_OPTIONS.baseDelay,
+  maxDelay = DEFAULT_RETRY_OPTIONS.maxDelay,
+  shouldRetry = defaultShouldRetry
+} = {}) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const retryError = error instanceof Error ? error : new Error(String(error));
+      const isLastAttempt = attempt === maxRetries;
+      if (isLastAttempt || !shouldRetry(retryError, attempt + 1)) {
+        throw error;
+      }
+      const delay = calculateDelay(attempt + 1, baseDelay, maxDelay);
+      console.warn(
+        `Attempt ${attempt + 1} failed: ${retryError.message}. Retrying in ${Math.round(delay)}ms...`
+      );
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError ?? new Error("Retry failed with unknown error");
+}
+
 // src/lib/content-policy-error.ts
 var PolicyTokenSchema = z2.string().trim().min(1).max(64).regex(/^[A-Z0-9_]+$/);
 var SafetyRatingSchema = z2.object({
@@ -552,6 +650,12 @@ async function withContentPolicyErrorHandling(operation) {
     rethrowContentPolicyError(error);
   }
 }
+async function withContentPolicyAwareRetry(operation, retryOptions) {
+  return withRetry(
+    () => withContentPolicyErrorHandling(operation),
+    retryOptions
+  );
+}
 function rethrowContentPolicyError(error) {
   const block = extractContentPolicyBlock(error);
   if (!block) {
@@ -588,7 +692,7 @@ function extractContentPolicyBlock(error) {
   if (NoObjectGeneratedError.isInstance(error) && error.finishReason === "content-filter") {
     return { reason: "CONTENT_FILTER" };
   }
-  if (!APICallError.isInstance(error) || !error.responseBody) {
+  if (!APICallError2.isInstance(error) || !error.responseBody) {
     return void 0;
   }
   try {
@@ -627,7 +731,7 @@ function getContentPolicyTokenUsage(error) {
   if (RetryError.isInstance(error)) {
     return getContentPolicyTokenUsage(error.lastError);
   }
-  if (!APICallError.isInstance(error) || !error.responseBody) {
+  if (!APICallError2.isInstance(error) || !error.responseBody) {
     return void 0;
   }
   try {
@@ -765,6 +869,7 @@ async function downloadImagesAsBase64(urls, options = {}, maxConcurrent = 5) {
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 
 // src/lib/workflow-crypto.ts
 import { gcm } from "@noble/ciphers/aes.js";
@@ -1051,6 +1156,7 @@ async function resolveMuxClient(credentials) {
 function resolveProviderApiKeyFromCredentials(provider, resolved) {
   const record = resolved;
   const openaiApiKey = readString(record, "openaiApiKey");
+  const basetenApiKey = readString(record, "basetenApiKey");
   const anthropicApiKey = readString(record, "anthropicApiKey");
   const googleApiKey = readString(record, "googleApiKey");
   const googleVisionApiKey = readString(record, "googleVisionApiKey");
@@ -1058,6 +1164,7 @@ function resolveProviderApiKeyFromCredentials(provider, resolved) {
   const elevenLabsApiKey = readString(record, "elevenLabsApiKey");
   const apiKeyMap = {
     "openai": openaiApiKey ?? env_default.OPENAI_API_KEY,
+    "baseten": basetenApiKey ?? env_default.BASETEN_API_KEY,
     "anthropic": anthropicApiKey ?? env_default.ANTHROPIC_API_KEY,
     "google": googleApiKey ?? env_default.GOOGLE_GENERATIVE_AI_API_KEY,
     "google-vision-api": googleVisionApiKey ?? env_default.GOOGLE_VISION_API_KEY,
@@ -1068,6 +1175,7 @@ function resolveProviderApiKeyFromCredentials(provider, resolved) {
   if (!apiKey) {
     const envVarNames = {
       "openai": "OPENAI_API_KEY",
+      "baseten": "BASETEN_API_KEY",
       "anthropic": "ANTHROPIC_API_KEY",
       "google": "GOOGLE_GENERATIVE_AI_API_KEY",
       "google-vision-api": "GOOGLE_VISION_API_KEY",
@@ -1106,6 +1214,60 @@ var DEFAULT_EMBEDDING_MODELS = {
   openai: "text-embedding-3-small",
   google: "gemini-embedding-001"
 };
+function resolveBasetenLanguageModelId(model) {
+  const resolved = model ?? env_default.BASETEN_MODEL;
+  if (!resolved) {
+    throw new Error(
+      'Baseten model is required. Pass `model` when provider is "baseten" or set BASETEN_MODEL.'
+    );
+  }
+  return resolved;
+}
+function resolveBasetenEmbeddingModelId(model) {
+  const resolved = model ?? env_default.BASETEN_EMBEDDING_MODEL;
+  if (!resolved) {
+    throw new Error(
+      'Baseten embedding model is required. Pass `model` when provider is "baseten" or set BASETEN_EMBEDDING_MODEL.'
+    );
+  }
+  return resolved;
+}
+function resolveOpenAICompatibleLanguageModelId(model) {
+  const resolved = model ?? env_default.OPENAI_COMPATIBLE_MODEL;
+  if (!resolved) {
+    throw new Error(
+      'OpenAI-compatible model is required. Pass `model` when provider is "openai-compatible" or set OPENAI_COMPATIBLE_MODEL.'
+    );
+  }
+  return resolved;
+}
+function resolveOpenAICompatibleEmbeddingModelId(model) {
+  const resolved = model ?? env_default.OPENAI_COMPATIBLE_EMBEDDING_MODEL;
+  if (!resolved) {
+    throw new Error(
+      'OpenAI-compatible embedding model is required. Pass `model` when provider is "openai-compatible" or set OPENAI_COMPATIBLE_EMBEDDING_MODEL.'
+    );
+  }
+  return resolved;
+}
+function getDefaultLanguageModel(provider) {
+  if (provider === "baseten") {
+    return resolveBasetenLanguageModelId();
+  }
+  if (provider === "openai-compatible") {
+    return resolveOpenAICompatibleLanguageModelId();
+  }
+  return DEFAULT_LANGUAGE_MODELS[provider];
+}
+function getDefaultEmbeddingModel(provider) {
+  if (provider === "baseten") {
+    return resolveBasetenEmbeddingModelId();
+  }
+  if (provider === "openai-compatible") {
+    return resolveOpenAICompatibleEmbeddingModelId();
+  }
+  return DEFAULT_EMBEDDING_MODELS[provider];
+}
 var LANGUAGE_MODELS = {
   openai: ["gpt-5.6-luna", "gpt-5.1", "gpt-5-mini"],
   anthropic: ["claude-sonnet-4-5"],
@@ -1171,7 +1333,7 @@ function getDefaultEvalModelConfigs() {
 function getAllEvalModelConfigs() {
   return Object.entries(LANGUAGE_MODELS).flatMap(([provider, models]) => models.map((modelId) => ({ provider, modelId })));
 }
-function isSupportedProvider(value) {
+function isSupportedEvalProvider(value) {
   return value === "openai" || value === "anthropic" || value === "google";
 }
 function parseEvalModelPair(value) {
@@ -1184,7 +1346,10 @@ function parseEvalModelPair(value) {
       `Invalid eval model pair "${value}". Use "provider:model" (example: "openai:gpt-5.6-luna").`
     );
   }
-  if (!isSupportedProvider(provider)) {
+  if (provider === "baseten" || provider === "openai-compatible") {
+    return void 0;
+  }
+  if (!isSupportedEvalProvider(provider)) {
     throw new Error(
       `Unsupported eval provider "${provider}" in "${value}". Supported providers: ${Object.keys(LANGUAGE_MODELS).join(", ")}.`
     );
@@ -1205,7 +1370,7 @@ function resolveEvalModelConfigs(options = {}) {
   const explicitPairs = options.modelPairs?.map((value) => value.trim()).filter(Boolean) ?? [];
   if (explicitPairs.length > 0) {
     const dedupedPairs = Array.from(new Set(explicitPairs));
-    return dedupedPairs.map(parseEvalModelPair);
+    return dedupedPairs.map(parseEvalModelPair).filter((config) => Boolean(config));
   }
   const selection = options.selection ?? "default";
   if (selection === "all") {
@@ -1238,30 +1403,140 @@ function resolveEvalModelConfigsFromEnv(environment = env_default) {
 var EVAL_MODEL_CONFIGS = resolveEvalModelConfigsFromEnv();
 function resolveLanguageModelConfig(options = {}) {
   const provider = options.provider || "openai";
-  const modelId = options.model || DEFAULT_LANGUAGE_MODELS[provider];
+  const modelId = options.model || getDefaultLanguageModel(provider);
   maybeWarnOrThrowForDeprecatedLanguageModel(provider, modelId);
   return { provider, modelId };
 }
 function resolveEmbeddingModelConfig(options = {}) {
   const provider = options.provider || "openai";
-  const modelId = options.model || DEFAULT_EMBEDDING_MODELS[provider];
+  const modelId = options.model || getDefaultEmbeddingModel(provider);
   return { provider, modelId };
 }
+var BASETEN_MODEL_APIS_BASE_URL = "https://inference.baseten.co/v1";
+function readCredentialString(record, key) {
+  const value = record?.[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function normalizeBaseUrl(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return trimmed.replace(/\/(chat\/completions|responses|embeddings)\/?$/, "").replace(/\/$/, "");
+}
+function isDedicatedBasetenModelUrl(value) {
+  return Boolean(value && (value.includes("/sync") || value.includes("/predict")));
+}
+function validateDedicatedBasetenUrl(url, kind) {
+  if (kind === "language") {
+    if (!url.includes("/sync/v1")) {
+      throw new Error(
+        `Baseten dedicated deployment URLs must be /sync/v1 endpoints for language models ("/predict" URLs are not supported). Update BASETEN_URL (or basetenUrl in credentials) to the deployment's /sync/v1 URL.`
+      );
+    }
+    return url;
+  }
+  if (!url.includes("/sync")) {
+    throw new Error(
+      "Baseten embeddings require a dedicated /sync or /sync/v1 deployment URL. Set BASETEN_EMBEDDING_URL or provide basetenEmbeddingUrl in credentials."
+    );
+  }
+  return url;
+}
+function basetenEndpointBaseUrl(url, kind) {
+  if (kind === "embedding" && !url.includes("/sync/v1")) {
+    return `${url}/v1`;
+  }
+  return url;
+}
+function basetenBaseUrlFromUrl(url, kind) {
+  const normalized = normalizeBaseUrl(url);
+  if (!normalized) {
+    if (kind === "embedding") {
+      throw new Error(
+        "Baseten embedding URL is required. Set BASETEN_EMBEDDING_URL or provide basetenEmbeddingUrl in credentials."
+      );
+    }
+    return BASETEN_MODEL_APIS_BASE_URL;
+  }
+  if (isDedicatedBasetenModelUrl(normalized)) {
+    return basetenEndpointBaseUrl(validateDedicatedBasetenUrl(normalized, kind), kind);
+  }
+  if (kind === "embedding") {
+    throw new Error(
+      "Baseten embeddings require a dedicated /sync or /sync/v1 deployment URL. Set BASETEN_EMBEDDING_URL or provide basetenEmbeddingUrl in credentials."
+    );
+  }
+  return normalized;
+}
+function resolveBasetenBaseUrlFromRecord(record, kind) {
+  if (kind === "embedding") {
+    return basetenBaseUrlFromUrl(
+      readCredentialString(record, "basetenEmbeddingUrl") ?? env_default.BASETEN_EMBEDDING_URL,
+      kind
+    );
+  }
+  return basetenBaseUrlFromUrl(
+    readCredentialString(record, "basetenUrl") ?? env_default.BASETEN_URL,
+    kind
+  );
+}
+function resolveOpenAICompatibleSettingsFromRecord(record, kind) {
+  const apiKey = readCredentialString(record, "openaiCompatibleApiKey") ?? env_default.OPENAI_COMPATIBLE_API_KEY;
+  const sharedBaseUrl = readCredentialString(record, "openaiCompatibleBaseUrl") ?? env_default.OPENAI_COMPATIBLE_BASE_URL;
+  const baseUrl = normalizeBaseUrl(
+    kind === "embedding" ? readCredentialString(record, "openaiCompatibleEmbeddingBaseUrl") ?? env_default.OPENAI_COMPATIBLE_EMBEDDING_BASE_URL ?? sharedBaseUrl : sharedBaseUrl
+  );
+  if (!baseUrl) {
+    throw new Error(
+      "OpenAI-compatible base URL is required. Set OPENAI_COMPATIBLE_BASE_URL or provide openaiCompatibleBaseUrl in credentials."
+    );
+  }
+  return { apiKey, baseURL: baseUrl };
+}
+function createBasetenProvider(apiKey, baseURL) {
+  return createOpenAICompatible({
+    name: "baseten",
+    apiKey,
+    baseURL,
+    supportsStructuredOutputs: true
+  });
+}
+function createGenericOpenAICompatibleProvider(settings) {
+  return createOpenAICompatible({
+    name: "openai-compatible",
+    ...settings,
+    supportsStructuredOutputs: true
+  });
+}
 async function createLanguageModelFromConfig(provider, modelId, credentials) {
   maybeWarnOrThrowForDeprecatedLanguageModel(provider, modelId);
+  const resolvedCredentials = await resolveWorkflowCredentials(credentials);
+  const credentialsRecord = resolvedCredentials;
   switch (provider) {
     case "openai": {
-      const apiKey = await resolveProviderApiKey("openai", credentials);
+      const apiKey = resolveProviderApiKeyFromCredentials("openai", resolvedCredentials);
       const openai = createOpenAI({ apiKey });
       return openai(modelId);
     }
+    case "baseten": {
+      const apiKey = resolveProviderApiKeyFromCredentials("baseten", resolvedCredentials);
+      const baseten = createBasetenProvider(apiKey, resolveBasetenBaseUrlFromRecord(credentialsRecord, "language"));
+      return baseten.chatModel(modelId);
+    }
+    case "openai-compatible": {
+      const compatible = createGenericOpenAICompatibleProvider(
+        resolveOpenAICompatibleSettingsFromRecord(credentialsRecord, "language")
+      );
+      return compatible.chatModel(modelId);
+    }
     case "anthropic": {
-      const apiKey = await resolveProviderApiKey("anthropic", credentials);
+      const apiKey = resolveProviderApiKeyFromCredentials("anthropic", resolvedCredentials);
       const anthropic = createAnthropic({ apiKey });
       return anthropic(modelId);
     }
     case "google": {
-      const apiKey = await resolveProviderApiKey("google", credentials);
+      const apiKey = resolveProviderApiKeyFromCredentials("google", resolvedCredentials);
       const google = createGoogleGenerativeAI({ apiKey });
       return google(modelId);
     }
@@ -1272,14 +1547,27 @@ async function createLanguageModelFromConfig(provider, modelId, credentials) {
   }
 }
 async function createEmbeddingModelFromConfig(provider, modelId, credentials) {
+  const resolvedCredentials = await resolveWorkflowCredentials(credentials);
+  const credentialsRecord = resolvedCredentials;
   switch (provider) {
     case "openai": {
-      const apiKey = await resolveProviderApiKey("openai", credentials);
+      const apiKey = resolveProviderApiKeyFromCredentials("openai", resolvedCredentials);
       const openai = createOpenAI({ apiKey });
       return openai.embedding(modelId);
     }
+    case "baseten": {
+      const apiKey = resolveProviderApiKeyFromCredentials("baseten", resolvedCredentials);
+      const baseten = createBasetenProvider(apiKey, resolveBasetenBaseUrlFromRecord(credentialsRecord, "embedding"));
+      return baseten.textEmbeddingModel(modelId);
+    }
+    case "openai-compatible": {
+      const compatible = createGenericOpenAICompatibleProvider(
+        resolveOpenAICompatibleSettingsFromRecord(credentialsRecord, "embedding")
+      );
+      return compatible.textEmbeddingModel(modelId);
+    }
     case "google": {
-      const apiKey = await resolveProviderApiKey("google", credentials);
+      const apiKey = resolveProviderApiKeyFromCredentials("google", resolvedCredentials);
       const google = createGoogleGenerativeAI({ apiKey });
       return google.textEmbeddingModel(modelId);
     }
@@ -1429,47 +1717,6 @@ function createLanguageSection(languageName) {
   };
 }
 
-// src/lib/retry.ts
-var DEFAULT_RETRY_OPTIONS = {
-  maxRetries: 3,
-  baseDelay: 2e3,
-  maxDelay: 1e4
-};
-function defaultShouldRetry(error, _attempt) {
-  return Boolean(error.message && error.message.includes("Timeout while downloading"));
-}
-function calculateDelay(attempt, baseDelay, maxDelay) {
-  const exponentialDelay = baseDelay * 2 ** (attempt - 1);
-  const delayWithJitter = exponentialDelay * (0.5 + Math.random() * 0.5);
-  return Math.min(delayWithJitter, maxDelay);
-}
-async function withRetry(fn, {
-  maxRetries = DEFAULT_RETRY_OPTIONS.maxRetries,
-  baseDelay = DEFAULT_RETRY_OPTIONS.baseDelay,
-  maxDelay = DEFAULT_RETRY_OPTIONS.maxDelay,
-  shouldRetry = defaultShouldRetry
-} = {}) {
-  let lastError;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      const retryError = error instanceof Error ? error : new Error(String(error));
-      const isLastAttempt = attempt === maxRetries;
-      if (isLastAttempt || !shouldRetry(retryError, attempt + 1)) {
-        throw error;
-      }
-      const delay = calculateDelay(attempt + 1, baseDelay, maxDelay);
-      console.warn(
-        `Attempt ${attempt + 1} failed: ${retryError.message}. Retrying in ${Math.round(delay)}ms...`
-      );
-      await new Promise((resolve) => setTimeout(resolve, delay));
-    }
-  }
-  throw lastError ?? new Error("Retry failed with unknown error");
-}
-
 // src/lib/workflow-scope.ts
 function hasWorkflowScopeBoundaries(scope) {
   return scope?.startTime !== void 0 || scope?.endTime !== void 0;
@@ -2632,8 +2879,9 @@ async function analyzeQuestions({
     normalizedQuestions,
     maxFreeFormAnswerLength
   );
-  const response = await withContentPolicyErrorHandling(() => generateText({
+  const response = await withContentPolicyAwareRetry(() => generateText({
     model,
+    maxRetries: 0,
     output: Output.object({ schema: responseSchema }),
     experimental_telemetry: { isEnabled: true },
     messages: [
@@ -2832,18 +3080,16 @@ async function askQuestionsInternal(assetId, questions, options, collectedUsage)
           credentials
         });
       } else {
-        analysisResponse = await withRetry(
-          () => analyzeQuestions({
-            provider: modelConfig.provider,
-            modelId: modelConfig.modelId,
-            userPrompt,
-            systemPrompt,
-            normalizedQuestions,
-            maxFreeFormAnswerLength,
-            imageDataUrl: storyboardUrl,
-            credentials
-          })
-        );
+        analysisResponse = await analyzeQuestions({
+          provider: modelConfig.provider,
+          modelId: modelConfig.modelId,
+          userPrompt,
+          systemPrompt,
+          normalizedQuestions,
+          maxFreeFormAnswerLength,
+          imageDataUrl: storyboardUrl,
+          credentials
+        });
       }
     }
   } catch (error) {
@@ -3045,8 +3291,9 @@ async function analyzeStoryboard({
 }) {
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
-  const response = await withContentPolicyErrorHandling(() => generateText2({
+  const response = await withContentPolicyAwareRetry(() => generateText2({
     model,
+    maxRetries: 0,
     output: Output2.object({ schema: burnedInCaptionsSchema }),
     experimental_telemetry: { isEnabled: true },
     messages: [
@@ -3194,24 +3441,21 @@ async function generateChaptersWithAI({
 }) {
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
-  const response = await withRetry(
-    () => withContentPolicyErrorHandling(
-      () => generateText3({
-        model,
-        output: Output3.object({ schema: chaptersSchema }),
-        messages: [
-          {
-            role: "system",
-            content: systemPrompt
-          },
-          {
-            role: "user",
-            content: userPrompt
-          }
-        ]
-      })
-    )
-  );
+  const response = await withContentPolicyAwareRetry(() => generateText3({
+    model,
+    maxRetries: 0,
+    output: Output3.object({ schema: chaptersSchema }),
+    messages: [
+      {
+        role: "system",
+        content: systemPrompt
+      },
+      {
+        role: "user",
+        content: userPrompt
+      }
+    ]
+  }));
   const output = getGeneratedOutputWithContentPolicyHandling(response);
   const unexpectedRootKeys = detectUnexpectedKeysFromRawText(
     response.text,
@@ -3952,8 +4196,9 @@ async function identifyProfanityWithAI({
     tag: "transcript",
     content: plainText
   });
-  const response = await withContentPolicyErrorHandling(() => generateText4({
+  const response = await withContentPolicyAwareRetry(() => generateText4({
     model,
+    maxRetries: 0,
     output: Output4.object({ schema: profanityDetectionSchema }),
     messages: [
       {
@@ -4478,9 +4723,10 @@ async function generateSingleChunkEmbedding({
 }) {
   "use step";
   const model = await createEmbeddingModelFromConfig(provider, modelId, credentials);
-  const response = await withRetry(
+  const response = await withContentPolicyAwareRetry(
     () => embed({
       model,
+      maxRetries: 0,
       value: chunk.text
     })
   );
@@ -5045,28 +5291,25 @@ async function fetchEngagementData(assetId, options) {
 async function generateInsightsWithAI(provider, modelId, systemPrompt, userPrompt, imageUrls, credentials) {
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
-  const response = await withRetry(
-    () => withContentPolicyErrorHandling(
-      () => generateText5({
-        model,
-        output: Output5.object({ schema: engagementInsightsSchema }),
-        experimental_telemetry: { isEnabled: true },
-        messages: [
-          {
-            role: "system",
-            content: systemPrompt
-          },
-          {
-            role: "user",
-            content: [
-              { type: "text", text: userPrompt },
-              ...imageUrls.map((url) => ({ type: "image", image: url }))
-            ]
-          }
+  const response = await withContentPolicyAwareRetry(() => generateText5({
+    model,
+    maxRetries: 0,
+    output: Output5.object({ schema: engagementInsightsSchema }),
+    experimental_telemetry: { isEnabled: true },
+    messages: [
+      {
+        role: "system",
+        content: systemPrompt
+      },
+      {
+        role: "user",
+        content: [
+          { type: "text", text: userPrompt },
+          ...imageUrls.map((url) => ({ type: "image", image: url }))
         ]
-      })
-    )
-  );
+      }
+    ]
+  }));
   const output = getGeneratedOutputWithContentPolicyHandling(response);
   if (!output) {
     throw new Error("AI returned empty or unparseable response");
@@ -5386,6 +5629,7 @@ async function getThumbnailUrls(playbackId, duration, options = {}) {
       timestamps.push(time);
     }
   }
+  timestamps = [...new Set(timestamps)];
   if (maxSamples !== void 0 && timestamps.length > maxSamples) {
     const newTimestamps = [];
     newTimestamps.push(resolvedScope.startTime);
@@ -5864,8 +6108,8 @@ async function getThumbnailUrlsFromTimestamps(playbackId, timestampsMs, options)
   "use step";
   const { width, shouldSign, credentials } = options;
   const baseUrl = getMuxThumbnailBaseUrl(playbackId);
-  const urlPromises = timestampsMs.map(async (tsMs) => {
-    const time = toThumbnailTimeSeconds(tsMs);
+  const times = [...new Set(timestampsMs.map(toThumbnailTimeSeconds))];
+  const urlPromises = times.map(async (time) => {
     const url = shouldSign ? await signUrl(baseUrl, playbackId, "thumbnail", { time, width }, credentials) : `${baseUrl}?time=${time}&width=${width}`;
     return { url, time };
   });
@@ -6351,8 +6595,9 @@ async function analyzeStoryboard2(imageDataUrl, provider, modelId, userPrompt, s
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
   const schema = buildSummarySchema(descriptionLength);
-  const response = await withContentPolicyErrorHandling(() => generateText6({
+  const response = await withContentPolicyAwareRetry(() => generateText6({
     model,
+    maxRetries: 0,
     output: Output6.object({
       name: "summary_metadata",
       description: "Structured summary with title, description, and keywords.",
@@ -6398,8 +6643,9 @@ async function analyzeAudioOnly(provider, modelId, userPrompt, systemPrompt, des
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
   const schema = buildSummarySchema(descriptionLength);
-  const response = await withContentPolicyErrorHandling(() => generateText6({
+  const response = await withContentPolicyAwareRetry(() => generateText6({
     model,
+    maxRetries: 0,
     output: Output6.object({
       name: "summary_metadata",
       description: "Structured summary with title, description, and keywords.",
@@ -6582,7 +6828,7 @@ async function getSummaryAndTagsInternal(assetId, options, collectedUsage) {
           workflowCredentials
         );
       } else {
-        analysisResponse = await withRetry(() => analyzeStoryboard2(
+        analysisResponse = await analyzeStoryboard2(
           storyboardUrl,
           modelConfig.provider,
           modelConfig.modelId,
@@ -6590,7 +6836,7 @@ async function getSummaryAndTagsInternal(assetId, options, collectedUsage) {
           systemPrompt,
           effectiveDescriptionLength,
           workflowCredentials
-        ));
+        );
       }
     }
   } catch (error) {
@@ -6834,6 +7080,59 @@ async function downloadAndUploadDubbedAudio({
   console.warn(`\u{1F517} Generated presigned URL (expires in ${expiryHours} hour${expiryHours === 1 ? "" : "s"})`);
   return presignedUrl;
 }
+async function downloadAndUploadDubTranscript({
+  dubbingId,
+  languageCode,
+  assetId,
+  toLanguageCode,
+  s3Endpoint,
+  s3Region,
+  s3Bucket,
+  storageAdapter,
+  s3SignedUrlExpirySeconds,
+  credentials
+}) {
+  "use step";
+  const elevenLabsApiKey = await getApiKeyFromEnv("elevenlabs", credentials);
+  const transcriptUrl = `https://api.elevenlabs.io/v1/dubbing/${dubbingId}/transcripts/${languageCode}/format/webvtt`;
+  const transcriptResponse = await fetch(transcriptUrl, {
+    headers: {
+      "xi-api-key": elevenLabsApiKey
+    }
+  });
+  if (!transcriptResponse.ok) {
+    throw new Error(`Failed to fetch dub transcript: ${transcriptResponse.statusText}`);
+  }
+  const transcriptBody = await transcriptResponse.json();
+  const transcriptVtt = transcriptBody.webvtt;
+  if (!transcriptVtt) {
+    throw new Error("Dub transcript response did not include webvtt content");
+  }
+  const s3AccessKeyId = env_default.S3_ACCESS_KEY_ID;
+  const s3SecretAccessKey = env_default.S3_SECRET_ACCESS_KEY;
+  const vttKey = `audio-translations/${assetId}/auto-to-${toLanguageCode}-${Date.now()}.vtt`;
+  await putObjectWithStorageAdapter({
+    accessKeyId: s3AccessKeyId,
+    secretAccessKey: s3SecretAccessKey,
+    endpoint: s3Endpoint,
+    region: s3Region,
+    bucket: s3Bucket,
+    key: vttKey,
+    body: transcriptVtt,
+    contentType: "text/vtt"
+  }, storageAdapter);
+  const presignedUrl = await createPresignedGetUrlWithStorageAdapter({
+    accessKeyId: s3AccessKeyId,
+    secretAccessKey: s3SecretAccessKey,
+    endpoint: s3Endpoint,
+    region: s3Region,
+    bucket: s3Bucket,
+    key: vttKey,
+    expiresInSeconds: s3SignedUrlExpirySeconds ?? 86400
+  }, storageAdapter);
+  console.warn(`\u2705 Dub transcript uploaded successfully to: ${vttKey}`);
+  return presignedUrl;
+}
 async function createAudioTrackOnMux(assetId, languageCode, presignedUrl, credentials) {
   "use step";
   const muxClient = await resolveMuxClient(credentials);
@@ -6860,6 +7159,7 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
     // 0 = auto-detect
     uploadToS3: uploadToS3Option,
     uploadToMux: uploadToMuxOption,
+    uploadCaptionsToMux = false,
     storageAdapter,
     credentials: providedCredentials
   } = options;
@@ -6869,7 +7169,7 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
   const credentials = providedCredentials;
   const effectiveStorageAdapter = storageAdapter;
   const uploadToMux = uploadToMuxOption !== false;
-  const uploadToS3 = uploadToS3Option || uploadToMux;
+  const uploadToS3 = uploadToS3Option || uploadToMux || uploadCaptionsToMux;
   const s3Endpoint = options.s3Endpoint ?? env_default.S3_ENDPOINT;
   const s3Region = options.s3Region ?? env_default.S3_REGION ?? "auto";
   const s3Bucket = options.s3Bucket ?? env_default.S3_BUCKET;
@@ -6950,10 +7250,12 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
   console.warn("\u2705 Dubbing completed successfully!");
   let presignedUrl;
   let uploadedTrackId;
+  let captionsPresignedUrl;
+  let captionsTrackId;
   if (uploadToS3) {
     console.warn("\u{1F4E5} Downloading dubbed audio from ElevenLabs and staging to S3...");
+    const downloadLangCode = targetLanguages[0] ?? toISO639_1(toLanguageCode);
     try {
-      const downloadLangCode = targetLanguages[0] ?? toISO639_1(toLanguageCode);
       presignedUrl = await downloadAndUploadDubbedAudio({
         dubbingId,
         languageCode: downloadLangCode,
@@ -6985,6 +7287,40 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
         console.warn(presignedUrl);
       }
     }
+    try {
+      console.warn("\u{1F4E5} Downloading dub transcript from ElevenLabs and staging to S3...");
+      captionsPresignedUrl = await downloadAndUploadDubTranscript({
+        dubbingId,
+        languageCode: downloadLangCode,
+        assetId,
+        toLanguageCode,
+        s3Endpoint,
+        s3Region,
+        s3Bucket,
+        storageAdapter: effectiveStorageAdapter,
+        s3SignedUrlExpirySeconds: options.s3SignedUrlExpirySeconds,
+        credentials
+      });
+      if (uploadCaptionsToMux) {
+        console.warn("\u{1F4F9} Adding dubbed captions track to Mux asset...");
+        const muxLangCode = toISO639_1(toLanguageCode);
+        const languageName = new Intl.DisplayNames(["en"], { type: "language" }).of(muxLangCode) || muxLangCode.toUpperCase();
+        captionsTrackId = await createTextTrackOnMux(
+          assetId,
+          muxLangCode,
+          `${languageName} (auto-dubbed)`,
+          captionsPresignedUrl,
+          credentials
+        );
+        console.warn(`\u2705 Captions track added to Mux asset with ID: ${captionsTrackId}`);
+      }
+    } catch (error) {
+      console.warn(`\u26A0\uFE0F Failed to attach dubbed captions: ${error instanceof Error ? error.message : "Unknown error"}`);
+      if (captionsPresignedUrl) {
+        console.warn("\u{1F517} You can manually add the captions track using this presigned URL:");
+        console.warn(captionsPresignedUrl);
+      }
+    }
   }
   const targetLanguage = getLanguageCodePair(toLanguageCode);
   return {
@@ -6994,6 +7330,8 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
     dubbingId,
     uploadedTrackId,
     presignedUrl,
+    captionsTrackId,
+    captionsPresignedUrl,
     usage: {
       metadata: {
         assetDurationSeconds
@@ -7004,7 +7342,7 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
 
 // src/workflows/translate-captions.ts
 import {
-  APICallError as APICallError2,
+  APICallError as APICallError3,
   generateText as generateText7,
   NoObjectGeneratedError as NoObjectGeneratedError2,
   Output as Output7,
@@ -7083,7 +7421,7 @@ function isProviderServiceError(error) {
   if (RetryError2.isInstance(error)) {
     return isProviderServiceError(error.lastError);
   }
-  if (APICallError2.isInstance(error)) {
+  if (APICallError3.isInstance(error)) {
     return true;
   }
   if (error instanceof Error && "cause" in error) {
@@ -7256,8 +7594,9 @@ async function translateVttWithAI({
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
   const sanitisedVttContent = stripVttMetadataBlocks(vttContent);
-  const response = await withContentPolicyErrorHandling(() => generateText7({
+  const response = await withContentPolicyAwareRetry(() => generateText7({
     model,
+    maxRetries: 0,
     output: Output7.object({ schema: translationSchema }),
     messages: [
       {
@@ -7322,8 +7661,9 @@ async function translateCueChunkWithAI({
     endTime: cue.endTime,
     text: cue.text
   }));
-  const response = await withContentPolicyErrorHandling(() => generateText7({
+  const response = await withContentPolicyAwareRetry(() => generateText7({
     model,
+    maxRetries: 0,
     output: Output7.object({ schema }),
     messages: [
       {