@mux/ai 0.29.0 → 0.31.0

package/dist/workflows/index.js

@@ -1,114 +1,11 @@
 // src/workflows/ask-questions.ts
 import { generateText, Output } from "ai";
 import dedent2 from "dedent";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
-// src/lib/image-download.ts
-import pRetry, { AbortError } from "p-retry";
-var BASE64_CHUNK_SIZE = 32768;
-function bytesToBase64(bytes) {
-  if (bytes.length === 0) {
-    return "";
-  }
-  let binary = "";
-  for (let i = 0; i < bytes.length; i += BASE64_CHUNK_SIZE) {
-    const chunk = bytes.subarray(i, i + BASE64_CHUNK_SIZE);
-    binary += String.fromCharCode(...chunk);
-  }
-  if (typeof globalThis.btoa !== "function") {
-    throw new TypeError("Base64 encoder is not available in this environment.");
-  }
-  return globalThis.btoa(binary);
-}
-var DEFAULT_OPTIONS = {
-  timeout: 1e4,
-  retries: 3,
-  retryDelay: 1e3,
-  maxRetryDelay: 1e4,
-  exponentialBackoff: true
-};
-async function downloadImageAsBase64(url, options = {}) {
-  "use step";
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  let attemptCount = 0;
-  return pRetry(
-    async () => {
-      attemptCount++;
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), opts.timeout);
-      try {
-        const response = await fetch(url, {
-          signal: controller.signal,
-          headers: {
-            "User-Agent": "@mux/ai image downloader"
-          }
-        });
-        clearTimeout(timeoutId);
-        if (!response.ok) {
-          if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-            throw new AbortError(`HTTP ${response.status}: ${response.statusText}`);
-          }
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const contentType = response.headers.get("content-type");
-        if (!contentType?.startsWith("image/")) {
-          throw new AbortError(`Invalid content type: ${contentType}. Expected image/*`);
-        }
-        const arrayBuffer = await response.arrayBuffer();
-        const buffer = new Uint8Array(arrayBuffer);
-        if (buffer.length === 0) {
-          throw new AbortError("Downloaded image is empty");
-        }
-        const base64Data = `data:${contentType};base64,${bytesToBase64(buffer)}`;
-        return {
-          base64Data,
-          buffer,
-          url,
-          contentType,
-          sizeBytes: buffer.length,
-          attempts: attemptCount
-        };
-      } catch (error) {
-        clearTimeout(timeoutId);
-        if (error instanceof AbortError) {
-          throw error;
-        }
-        if (error instanceof Error) {
-          if (error.name === "AbortError") {
-            throw new Error(`Request timeout after ${opts.timeout}ms`);
-          }
-          throw new Error(`Download failed: ${error.message}`);
-        }
-        throw new Error("Unknown download error");
-      }
-    },
-    {
-      retries: opts.retries,
-      minTimeout: opts.retryDelay,
-      maxTimeout: opts.maxRetryDelay,
-      factor: opts.exponentialBackoff ? 2 : 1,
-      randomize: true,
-      // Add jitter to prevent thundering herd
-      onFailedAttempt: (error) => {
-        console.warn(`Image download attempt ${error.attemptNumber} failed for ${url}`);
-        if (error.retriesLeft > 0) {
-          console.warn(`Retrying... (${error.retriesLeft} attempts left)`);
-        }
-      }
-    }
-  );
-}
-async function downloadImagesAsBase64(urls, options = {}, maxConcurrent = 5) {
-  "use step";
-  const results = [];
-  for (let i = 0; i < urls.length; i += maxConcurrent) {
-    const batch = urls.slice(i, i + maxConcurrent);
-    const batchPromises = batch.map((url) => downloadImageAsBase64(url, options));
-    const batchResults = await Promise.all(batchPromises);
-    results.push(...batchResults);
-  }
-  return results;
-}
+// src/lib/content-policy-error.ts
+import { APICallError, NoObjectGeneratedError, RetryError } from "ai";
+import { z as z2 } from "zod";
 
 // src/lib/prompt-fragments.ts
 import dedent from "dedent";
@@ -179,7 +76,7 @@ var EnvSchema = z.object({
   MUX_TEST_ASSET_ID_VIOLENT_AUDIO_ONLY: optionalString("Mux test asset ID for audio-only assets with violent content.", "Mux test asset id for audio-only assets with violent content for testing"),
   // Eval config
   MUX_AI_EVAL_MODEL_SET: optionalString("Eval model selection mode.", "Choose between 'default' (provider defaults only) or 'all' (all configured models)"),
-  MUX_AI_EVAL_MODELS: optionalString("Comma-separated eval model pairs.", "Comma-separated provider:model pairs (e.g. 'openai:gpt-5.1,anthropic:claude-sonnet-4-5,google:gemini-3-flash-preview')"),
+  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"),
   ANTHROPIC_API_KEY: optionalString("Anthropic API key for Claude-backed workflows.", "Anthropic API key"),
@@ -498,7 +395,8 @@ var TOKEN_USAGE_FIELDS = [
   "outputTokens",
   "totalTokens",
   "reasoningTokens",
-  "cachedInputTokens"
+  "cachedInputTokens",
+  "cacheWriteTokens"
 ];
 function isDefinedTokenUsageValue(value) {
   return typeof value === "number";
@@ -540,6 +438,12 @@ function getErrorTokenUsage(error) {
       extracted.cachedInputTokens = cacheReadTokens;
     }
   }
+  if (extracted.cacheWriteTokens === void 0) {
+    const cacheWriteTokens = source.inputTokenDetails?.cacheWriteTokens;
+    if (typeof cacheWriteTokens === "number") {
+      extracted.cacheWriteTokens = cacheWriteTokens;
+    }
+  }
   return Object.keys(extracted).length > 0 ? extracted : void 0;
 }
 function rethrowWithTokenUsage(error, collectedUsage) {
@@ -565,6 +469,9 @@ var MuxAiError = class extends Error {
     this.publicMessage = message;
     this.retryable = opts?.retryable ?? false;
   }
+  static is(value) {
+    return typeof value === "object" && value !== null && "__robots_error" in value && value.__robots_error === true;
+  }
 };
 function extractErrorDetail(error) {
   if (error instanceof Error && error.message) {
@@ -582,7 +489,7 @@ function extractErrorDetail(error) {
   return "Unknown error";
 }
 function wrapError(error, message) {
-  if (error instanceof MuxAiError) {
+  if (MuxAiError.is(error)) {
     throw error;
   }
   const rawDetail = extractErrorDetail(error);
@@ -600,6 +507,260 @@ function wrapError(error, message) {
   throw wrapped;
 }
 
+// src/lib/content-policy-error.ts
+var PolicyTokenSchema = z2.string().trim().min(1).max(64).regex(/^[A-Z0-9_]+$/);
+var SafetyRatingSchema = z2.object({
+  category: PolicyTokenSchema.nullish(),
+  blocked: z2.boolean().nullish()
+});
+var ContentPolicyResponseSchema = z2.object({
+  promptFeedback: z2.object({
+    blockReason: PolicyTokenSchema.nullish(),
+    safetyRatings: z2.array(SafetyRatingSchema).max(32).nullish()
+  }).nullish(),
+  candidates: z2.array(z2.object({
+    finishReason: PolicyTokenSchema.nullish(),
+    safetyRatings: z2.array(SafetyRatingSchema).max(32).nullish()
+  })).max(8).nullish()
+});
+var ContentPolicyUsageResponseSchema = z2.object({
+  usageMetadata: z2.object({
+    promptTokenCount: z2.number().finite().nonnegative().nullish(),
+    candidatesTokenCount: z2.number().finite().nonnegative().nullish(),
+    totalTokenCount: z2.number().finite().nonnegative().nullish(),
+    cachedContentTokenCount: z2.number().finite().nonnegative().nullish(),
+    thoughtsTokenCount: z2.number().finite().nonnegative().nullish()
+  }).nullish()
+});
+var CONTENT_POLICY_REASONS = /* @__PURE__ */ new Set([
+  "BLOCKLIST",
+  "ESCALATION",
+  "IMAGE_PROHIBITED_CONTENT",
+  "IMAGE_RECITATION",
+  "IMAGE_SAFETY",
+  "JAILBREAK",
+  "MODEL_ARMOR",
+  "PROHIBITED_CONTENT",
+  "RECITATION",
+  "SAFETY",
+  "SPII"
+]);
+async function withContentPolicyErrorHandling(operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    rethrowContentPolicyError(error);
+  }
+}
+function rethrowContentPolicyError(error) {
+  const block = extractContentPolicyBlock(error);
+  if (!block) {
+    throw error;
+  }
+  throwContentPolicyError(block, getContentPolicyTokenUsage(error));
+}
+function getGeneratedOutputWithContentPolicyHandling(response) {
+  if (response.finishReason === "content-filter") {
+    const rawReason = PolicyTokenSchema.safeParse(response.rawFinishReason);
+    const reason = rawReason.success && isContentPolicyReason(rawReason.data) ? rawReason.data : "CONTENT_FILTER";
+    throwContentPolicyError({ reason }, getErrorTokenUsage(response));
+  }
+  return response.output;
+}
+function throwContentPolicyError(block, usage) {
+  const category = block.category ? `; category: ${block.category}` : "";
+  const contentPolicyError = new MuxAiError(
+    `The supplied content was blocked by a content policy (reason: ${block.reason}${category}).`,
+    {
+      type: "content_policy_error",
+      retryable: false
+    }
+  );
+  if (usage) {
+    contentPolicyError.usage = usage;
+  }
+  throw contentPolicyError;
+}
+function extractContentPolicyBlock(error) {
+  if (RetryError.isInstance(error)) {
+    return extractContentPolicyBlock(error.lastError);
+  }
+  if (NoObjectGeneratedError.isInstance(error) && error.finishReason === "content-filter") {
+    return { reason: "CONTENT_FILTER" };
+  }
+  if (!APICallError.isInstance(error) || !error.responseBody) {
+    return void 0;
+  }
+  try {
+    const parsed = ContentPolicyResponseSchema.safeParse(JSON.parse(error.responseBody));
+    if (!parsed.success) {
+      return void 0;
+    }
+    const promptReason = parsed.data.promptFeedback?.blockReason;
+    if (isContentPolicyReason(promptReason)) {
+      return {
+        reason: promptReason,
+        category: findBlockedCategory(parsed.data.promptFeedback?.safetyRatings)
+      };
+    }
+    for (const candidate of parsed.data.candidates ?? []) {
+      if (isContentPolicyReason(candidate.finishReason)) {
+        return {
+          reason: candidate.finishReason,
+          category: findBlockedCategory(candidate.safetyRatings)
+        };
+      }
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function isContentPolicyReason(reason) {
+  return Boolean(reason && CONTENT_POLICY_REASONS.has(reason));
+}
+function getContentPolicyTokenUsage(error) {
+  const errorUsage = getErrorTokenUsage(error);
+  if (errorUsage) {
+    return errorUsage;
+  }
+  if (RetryError.isInstance(error)) {
+    return getContentPolicyTokenUsage(error.lastError);
+  }
+  if (!APICallError.isInstance(error) || !error.responseBody) {
+    return void 0;
+  }
+  try {
+    const parsed = ContentPolicyUsageResponseSchema.safeParse(JSON.parse(error.responseBody));
+    const usage = parsed.success ? parsed.data.usageMetadata : void 0;
+    if (!usage) {
+      return void 0;
+    }
+    const inputTokens = usage.promptTokenCount ?? 0;
+    const reasoningTokens = usage.thoughtsTokenCount ?? 0;
+    const outputTokens = (usage.candidatesTokenCount ?? 0) + reasoningTokens;
+    return {
+      inputTokens,
+      outputTokens,
+      totalTokens: usage.totalTokenCount ?? inputTokens + outputTokens,
+      reasoningTokens,
+      cachedInputTokens: usage.cachedContentTokenCount ?? 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+function findBlockedCategory(ratings) {
+  return ratings?.find((rating) => rating.blocked === true)?.category ?? void 0;
+}
+
+// src/lib/image-download.ts
+import pRetry, { AbortError } from "p-retry";
+var BASE64_CHUNK_SIZE = 32768;
+function bytesToBase64(bytes) {
+  if (bytes.length === 0) {
+    return "";
+  }
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += BASE64_CHUNK_SIZE) {
+    const chunk = bytes.subarray(i, i + BASE64_CHUNK_SIZE);
+    binary += String.fromCharCode(...chunk);
+  }
+  if (typeof globalThis.btoa !== "function") {
+    throw new TypeError("Base64 encoder is not available in this environment.");
+  }
+  return globalThis.btoa(binary);
+}
+var DEFAULT_OPTIONS = {
+  timeout: 1e4,
+  retries: 3,
+  retryDelay: 1e3,
+  maxRetryDelay: 1e4,
+  exponentialBackoff: true
+};
+async function downloadImageAsBase64(url, options = {}) {
+  "use step";
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let attemptCount = 0;
+  return pRetry(
+    async () => {
+      attemptCount++;
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), opts.timeout);
+      try {
+        const response = await fetch(url, {
+          signal: controller.signal,
+          headers: {
+            "User-Agent": "@mux/ai image downloader"
+          }
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+            throw new AbortError(`HTTP ${response.status}: ${response.statusText}`);
+          }
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const contentType = response.headers.get("content-type");
+        if (!contentType?.startsWith("image/")) {
+          throw new AbortError(`Invalid content type: ${contentType}. Expected image/*`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = new Uint8Array(arrayBuffer);
+        if (buffer.length === 0) {
+          throw new AbortError("Downloaded image is empty");
+        }
+        const base64Data = `data:${contentType};base64,${bytesToBase64(buffer)}`;
+        return {
+          base64Data,
+          buffer,
+          url,
+          contentType,
+          sizeBytes: buffer.length,
+          attempts: attemptCount
+        };
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof AbortError) {
+          throw error;
+        }
+        if (error instanceof Error) {
+          if (error.name === "AbortError") {
+            throw new Error(`Request timeout after ${opts.timeout}ms`);
+          }
+          throw new Error(`Download failed: ${error.message}`);
+        }
+        throw new Error("Unknown download error");
+      }
+    },
+    {
+      retries: opts.retries,
+      minTimeout: opts.retryDelay,
+      maxTimeout: opts.maxRetryDelay,
+      factor: opts.exponentialBackoff ? 2 : 1,
+      randomize: true,
+      // Add jitter to prevent thundering herd
+      onFailedAttempt: (error) => {
+        console.warn(`Image download attempt ${error.attemptNumber} failed for ${url}`);
+        if (error.retriesLeft > 0) {
+          console.warn(`Retrying... (${error.retriesLeft} attempts left)`);
+        }
+      }
+    }
+  );
+}
+async function downloadImagesAsBase64(urls, options = {}, maxConcurrent = 5) {
+  "use step";
+  const results = [];
+  for (let i = 0; i < urls.length; i += maxConcurrent) {
+    const batch = urls.slice(i, i + maxConcurrent);
+    const batchPromises = batch.map((url) => downloadImageAsBase64(url, options));
+    const batchResults = await Promise.all(batchPromises);
+    results.push(...batchResults);
+  }
+  return results;
+}
+
 // src/lib/providers.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
@@ -936,7 +1097,8 @@ async function resolveMuxSigningContext(credentials) {
 
 // src/lib/providers.ts
 var DEFAULT_LANGUAGE_MODELS = {
-  openai: "gpt-5.1",
+  // GPT-5.6 models default to medium reasoning when no effort is specified.
+  openai: "gpt-5.6-luna",
   anthropic: "claude-sonnet-4-5",
   google: "gemini-3-flash-preview"
 };
@@ -945,11 +1107,20 @@ var DEFAULT_EMBEDDING_MODELS = {
   google: "gemini-embedding-001"
 };
 var LANGUAGE_MODELS = {
-  openai: ["gpt-5.1", "gpt-5-mini"],
+  openai: ["gpt-5.6-luna", "gpt-5.1", "gpt-5-mini"],
   anthropic: ["claude-sonnet-4-5"],
   google: ["gemini-3-flash-preview", "gemini-3.1-flash-lite", "gemini-2.5-flash"]
 };
 var LANGUAGE_MODEL_DEPRECATIONS = [
+  {
+    provider: "openai",
+    modelId: "gpt-5.1",
+    replacementModelId: "gpt-5.6-luna",
+    phase: "warn",
+    deprecatedOn: "2026-08-01",
+    sunsetOn: "2026-10-01",
+    reason: "GPT-5.6 Luna with its default medium reasoning effort is the new OpenAI default."
+  },
   {
     provider: "google",
     modelId: "gemini-2.5-flash",
@@ -1010,7 +1181,7 @@ function parseEvalModelPair(value) {
   const modelId = modelIdRaw?.trim();
   if (!provider || !modelId) {
     throw new Error(
-      `Invalid eval model pair "${value}". Use "provider:model" (example: "openai:gpt-5.1").`
+      `Invalid eval model pair "${value}". Use "provider:model" (example: "openai:gpt-5.6-luna").`
     );
   }
   if (!isSupportedProvider(provider)) {
@@ -1259,13 +1430,23 @@ function createLanguageSection(languageName) {
 }
 
 // src/lib/retry.ts
+import { DownloadError } from "ai";
 var DEFAULT_RETRY_OPTIONS = {
   maxRetries: 3,
   baseDelay: 2e3,
   maxDelay: 1e4
 };
 function defaultShouldRetry(error, _attempt) {
-  return Boolean(error.message && error.message.includes("Timeout while downloading"));
+  if (error.message.includes("Timeout while downloading")) {
+    return true;
+  }
+  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);
@@ -1283,19 +1464,20 @@ async function withRetry(fn, {
     try {
       return await fn();
     } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
+      lastError = error;
+      const retryError = error instanceof Error ? error : new Error(String(error));
       const isLastAttempt = attempt === maxRetries;
-      if (isLastAttempt || !shouldRetry(lastError, attempt + 1)) {
-        throw lastError;
+      if (isLastAttempt || !shouldRetry(retryError, attempt + 1)) {
+        throw error;
       }
       const delay = calculateDelay(attempt + 1, baseDelay, maxDelay);
       console.warn(
-        `Attempt ${attempt + 1} failed: ${lastError.message}. Retrying in ${Math.round(delay)}ms...`
+        `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");
+  throw lastError ?? new Error("Retry failed with unknown error");
 }
 
 // src/lib/workflow-scope.ts
@@ -2074,17 +2256,20 @@ async function fetchTranscriptForAsset(asset, playbackId, options = {}) {
 }
 
 // src/workflows/ask-questions.ts
-var questionAnswerSchema = z2.object({
-  question: z2.string().describe("The full text of the original question"),
-  answer: z2.string().nullable(),
-  confidence: z2.number(),
-  reasoning: z2.string().max(1e3),
-  skipped: z2.boolean()
+var ASK_QUESTIONS_MAX_QUESTION_LENGTH = 600;
+var ASK_QUESTIONS_DEFAULT_MAX_ANSWER_OPTION_LENGTH = 150;
+var ASK_QUESTIONS_DEFAULT_MAX_FREE_FORM_ANSWER_LENGTH = 500;
+var questionAnswerSchema = z3.object({
+  question: z3.string().describe("The full text of the original question"),
+  answer: z3.string().nullable(),
+  confidence: z3.number(),
+  reasoning: z3.string().max(1e3),
+  skipped: z3.boolean()
 });
 var SKIP_SENTINEL = "__SKIPPED__";
 function createAskQuestionsSchema(answerSchema) {
-  return z2.object({
-    answers: z2.array(
+  return z3.object({
+    answers: z3.array(
       questionAnswerSchema.extend({
         answer: answerSchema
       })
@@ -2434,12 +2619,12 @@ function buildResponseSchemaForQuestions(normalizedQuestions, maxFreeFormAnswerL
       SKIP_SENTINEL.length,
       longestConstrained
     );
-    return createAskQuestionsSchema(z2.string().min(1).max(schemaMax));
+    return createAskQuestionsSchema(z3.string().min(1).max(schemaMax));
   }
   const allowed = Array.from(
     new Set(normalizedQuestions.flatMap(allowedAnswersForQuestion))
   );
-  return createAskQuestionsSchema(z2.enum([...allowed, SKIP_SENTINEL]));
+  return createAskQuestionsSchema(z3.enum([...allowed, SKIP_SENTINEL]));
 }
 async function analyzeQuestions({
   provider,
@@ -2457,7 +2642,7 @@ async function analyzeQuestions({
     normalizedQuestions,
     maxFreeFormAnswerLength
   );
-  const response = await generateText({
+  const response = await withContentPolicyErrorHandling(() => generateText({
     model,
     output: Output.object({ schema: responseSchema }),
     experimental_telemetry: { isEnabled: true },
@@ -2474,11 +2659,12 @@ async function analyzeQuestions({
         ] : userPrompt
       }
     ]
-  });
-  if (!response.output) {
+  }));
+  const output = getGeneratedOutputWithContentPolicyHandling(response);
+  if (!output) {
     throw new Error("Ask-questions output missing");
   }
-  const parsed = responseSchema.parse(response.output);
+  const parsed = responseSchema.parse(output);
   const unexpectedRootKeys = detectUnexpectedKeysFromRawText(
     response.text,
     responseSchema.keyof().options
@@ -2500,7 +2686,8 @@ async function analyzeQuestions({
       outputTokens: response.usage.outputTokens,
       totalTokens: response.usage.totalTokens,
       reasoningTokens: response.usage.reasoningTokens,
-      cachedInputTokens: response.usage.cachedInputTokens
+      cachedInputTokens: response.usage.cachedInputTokens,
+      cacheWriteTokens: response.usage.inputTokenDetails?.cacheWriteTokens
     },
     unexpectedRootKeys,
     unexpectedAnswerKeys
@@ -2519,7 +2706,6 @@ async function askQuestionsInternal(assetId, questions, options, collectedUsage)
   if (!questions || questions.length === 0) {
     throw new MuxAiError("At least one question must be provided.", { type: "validation_error" });
   }
-  const MAX_QUESTION_LENGTH = 500;
   questions.forEach((q, idx) => {
     if (!q.question || typeof q.question !== "string" || !q.question.trim()) {
       throw new MuxAiError(
@@ -2527,15 +2713,14 @@ async function askQuestionsInternal(assetId, questions, options, collectedUsage)
         { type: "validation_error" }
       );
     }
-    if (q.question.length > MAX_QUESTION_LENGTH) {
+    if (q.question.length > ASK_QUESTIONS_MAX_QUESTION_LENGTH) {
       throw new MuxAiError(
-        `Question at index ${idx} exceeds the ${MAX_QUESTION_LENGTH}-character limit (received ${q.question.length}).`,
+        `Question at index ${idx} exceeds the ${ASK_QUESTIONS_MAX_QUESTION_LENGTH}-character limit (received ${q.question.length}).`,
         { type: "validation_error" }
       );
     }
   });
-  const DEFAULT_MAX_ANSWER_OPTION_LENGTH = 150;
-  const maxAnswerOptionLength = options?.maxAnswerOptionLength ?? DEFAULT_MAX_ANSWER_OPTION_LENGTH;
+  const maxAnswerOptionLength = options?.maxAnswerOptionLength ?? ASK_QUESTIONS_DEFAULT_MAX_ANSWER_OPTION_LENGTH;
   if (!Number.isFinite(maxAnswerOptionLength) || maxAnswerOptionLength <= 0) {
     throw new MuxAiError(
       `maxAnswerOptionLength must be a positive number (received ${maxAnswerOptionLength}).`,
@@ -2554,8 +2739,7 @@ async function askQuestionsInternal(assetId, questions, options, collectedUsage)
       }
     }
   });
-  const DEFAULT_MAX_FREE_FORM_ANSWER_LENGTH = 500;
-  const maxFreeFormAnswerLength = options?.maxFreeFormAnswerLength ?? DEFAULT_MAX_FREE_FORM_ANSWER_LENGTH;
+  const maxFreeFormAnswerLength = options?.maxFreeFormAnswerLength ?? ASK_QUESTIONS_DEFAULT_MAX_FREE_FORM_ANSWER_LENGTH;
   if (!Number.isFinite(maxFreeFormAnswerLength) || maxFreeFormAnswerLength <= 0) {
     throw new MuxAiError(
       `maxFreeFormAnswerLength must be a positive number (received ${maxFreeFormAnswerLength}).`,
@@ -2757,11 +2941,11 @@ async function askQuestionsInternal(assetId, questions, options, collectedUsage)
 // src/workflows/burned-in-captions.ts
 import { generateText as generateText2, Output as Output2 } from "ai";
 import dedent3 from "dedent";
-import { z as z3 } from "zod";
-var burnedInCaptionsSchema = z3.object({
-  hasBurnedInCaptions: z3.boolean(),
-  confidence: z3.number(),
-  detectedLanguage: z3.string().max(100).nullable()
+import { z as z4 } from "zod";
+var burnedInCaptionsSchema = z4.object({
+  hasBurnedInCaptions: z4.boolean(),
+  confidence: z4.number(),
+  detectedLanguage: z4.string().max(100).nullable()
 });
 var SYSTEM_PROMPT2 = promptDedent`
   <role>
@@ -2871,7 +3055,7 @@ async function analyzeStoryboard({
 }) {
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
-  const response = await generateText2({
+  const response = await withContentPolicyErrorHandling(() => generateText2({
     model,
     output: Output2.object({ schema: burnedInCaptionsSchema }),
     experimental_telemetry: { isEnabled: true },
@@ -2888,22 +3072,24 @@ async function analyzeStoryboard({
         ]
       }
     ]
-  });
+  }));
+  const output = getGeneratedOutputWithContentPolicyHandling(response);
   const unexpectedKeys = detectUnexpectedKeysFromRawText(
     response.text,
     burnedInCaptionsSchema.keyof().options
   );
   return {
     result: {
-      ...response.output,
-      confidence: Math.min(1, Math.max(0, response.output.confidence))
+      ...output,
+      confidence: Math.min(1, Math.max(0, output.confidence))
     },
     usage: {
       inputTokens: response.usage.inputTokens,
       outputTokens: response.usage.outputTokens,
       totalTokens: response.usage.totalTokens,
       reasoningTokens: response.usage.reasoningTokens,
-      cachedInputTokens: response.usage.cachedInputTokens
+      cachedInputTokens: response.usage.cachedInputTokens,
+      cacheWriteTokens: response.usage.inputTokenDetails?.cacheWriteTokens
     },
     unexpectedKeys
   };
@@ -2960,14 +3146,14 @@ async function hasBurnedInCaptionsInternal(assetId, options, collectedUsage) {
       credentials
     });
   } else {
-    analysisResponse = await analyzeStoryboard({
+    analysisResponse = await withRetry(() => analyzeStoryboard({
       imageDataUrl: imageUrl,
       provider: modelConfig.provider,
       modelId: modelConfig.modelId,
       userPrompt,
       systemPrompt: SYSTEM_PROMPT2,
       credentials
-    });
+    }));
   }
   collectedUsage.push(analysisResponse.usage);
   if (!analysisResponse.result) {
@@ -3001,13 +3187,13 @@ async function hasBurnedInCaptionsInternal(assetId, options, collectedUsage) {
 // src/workflows/chapters.ts
 import { generateText as generateText3, Output as Output3 } from "ai";
 import dedent4 from "dedent";
-import { z as z4 } from "zod";
-var chapterSchema = z4.object({
-  startTime: z4.number(),
-  title: z4.string().max(300)
+import { z as z5 } from "zod";
+var chapterSchema = z5.object({
+  startTime: z5.number(),
+  title: z5.string().max(300)
 });
-var chaptersSchema = z4.object({
-  chapters: z4.array(chapterSchema)
+var chaptersSchema = z5.object({
+  chapters: z5.array(chapterSchema)
 });
 async function generateChaptersWithAI({
   provider,
@@ -3019,21 +3205,24 @@ async function generateChaptersWithAI({
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
   const response = await withRetry(
-    () => generateText3({
-      model,
-      output: Output3.object({ schema: chaptersSchema }),
-      messages: [
-        {
-          role: "system",
-          content: systemPrompt
-        },
-        {
-          role: "user",
-          content: userPrompt
-        }
-      ]
-    })
+    () => withContentPolicyErrorHandling(
+      () => generateText3({
+        model,
+        output: Output3.object({ schema: chaptersSchema }),
+        messages: [
+          {
+            role: "system",
+            content: systemPrompt
+          },
+          {
+            role: "user",
+            content: userPrompt
+          }
+        ]
+      })
+    )
   );
+  const output = getGeneratedOutputWithContentPolicyHandling(response);
   const unexpectedRootKeys = detectUnexpectedKeysFromRawText(
     response.text,
     chaptersSchema.keyof().options
@@ -3049,13 +3238,14 @@ async function generateChaptersWithAI({
   } catch {
   }
   return {
-    chapters: response.output,
+    chapters: output,
     usage: {
       inputTokens: response.usage.inputTokens,
       outputTokens: response.usage.outputTokens,
       totalTokens: response.usage.totalTokens,
       reasoningTokens: response.usage.reasoningTokens,
-      cachedInputTokens: response.usage.cachedInputTokens
+      cachedInputTokens: response.usage.cachedInputTokens,
+      cacheWriteTokens: response.usage.inputTokenDetails?.cacheWriteTokens
     },
     unexpectedRootKeys,
     unexpectedChapterKeys
@@ -3311,7 +3501,7 @@ async function generateChaptersInternal(assetId, options, collectedUsage) {
 
 // src/workflows/edit-captions.ts
 import { generateText as generateText4, Output as Output4 } from "ai";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/lib/mux-tracks.ts
 async function fetchVttFromMux(vttUrl) {
@@ -3594,8 +3784,8 @@ async function createPresignedGetUrlWithStorageAdapter(input, adapter) {
 }
 
 // src/workflows/edit-captions.ts
-var profanityDetectionSchema = z5.object({
-  profanity: z5.array(z5.string().max(100)).describe(
+var profanityDetectionSchema = z6.object({
+  profanity: z6.array(z6.string().max(100)).describe(
     "Unique profane words or short phrases exactly as they appear in the transcript text. Include each distinct form only once (e.g., if 'fuck' and 'fucking' both appear, list both)."
   )
 });
@@ -3772,7 +3962,7 @@ async function identifyProfanityWithAI({
     tag: "transcript",
     content: plainText
   });
-  const response = await generateText4({
+  const response = await withContentPolicyErrorHandling(() => generateText4({
     model,
     output: Output4.object({ schema: profanityDetectionSchema }),
     messages: [
@@ -3787,19 +3977,21 @@ async function identifyProfanityWithAI({
 ${transcriptSection}`
       }
     ]
-  });
+  }));
+  const output = getGeneratedOutputWithContentPolicyHandling(response);
   const unexpectedKeys = detectUnexpectedKeysFromRawText(
     response.text,
     profanityDetectionSchema.keyof().options
   );
   return {
-    profanity: response.output.profanity,
+    profanity: output.profanity,
     usage: {
       inputTokens: response.usage.inputTokens,
       outputTokens: response.usage.outputTokens,
       totalTokens: response.usage.totalTokens,
       reasoningTokens: response.usage.reasoningTokens,
-      cachedInputTokens: response.usage.cachedInputTokens
+      cachedInputTokens: response.usage.cachedInputTokens,
+      cacheWriteTokens: response.usage.inputTokenDetails?.cacheWriteTokens
     },
     unexpectedKeys
   };
@@ -4442,7 +4634,7 @@ async function generateVideoEmbeddings(assetId, options = {}) {
 // src/workflows/engagement-insights.ts
 import { generateText as generateText5, Output as Output5 } from "ai";
 import dedent5 from "dedent";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/primitives/heatmap.ts
 async function getHeatmapForAsset(assetId, options = {}) {
@@ -4589,20 +4781,20 @@ async function getShotsForAsset(assetId, options = {}) {
 }
 
 // src/workflows/engagement-insights.ts
-var aiMomentInsightSchema = z6.object({
-  hotspotIndex: z6.number(),
-  startMs: z6.number(),
-  endMs: z6.number(),
-  timestamp: z6.string(),
-  engagementScore: z6.number(),
-  insight: z6.string().max(1e3)
+var aiMomentInsightSchema = z7.object({
+  hotspotIndex: z7.number(),
+  startMs: z7.number(),
+  endMs: z7.number(),
+  timestamp: z7.string(),
+  engagementScore: z7.number(),
+  insight: z7.string().max(1e3)
 });
-var aiOverallInsightSchema = z6.object({
-  summary: z6.string().max(2e3),
-  trends: z6.array(z6.string().max(500))
+var aiOverallInsightSchema = z7.object({
+  summary: z7.string().max(2e3),
+  trends: z7.array(z7.string().max(500))
 });
-var engagementInsightsSchema = z6.object({
-  momentInsights: z6.array(aiMomentInsightSchema),
+var engagementInsightsSchema = z7.object({
+  momentInsights: z7.array(aiMomentInsightSchema),
   overallInsight: aiOverallInsightSchema
 });
 var SYSTEM_PROMPT4 = promptDedent`
@@ -4864,26 +5056,29 @@ async function generateInsightsWithAI(provider, modelId, systemPrompt, userPromp
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
   const response = await withRetry(
-    () => 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 }))
-          ]
-        }
-      ]
-    })
+    () => 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 }))
+            ]
+          }
+        ]
+      })
+    )
   );
-  if (!response.output) {
+  const output = getGeneratedOutputWithContentPolicyHandling(response);
+  if (!output) {
     throw new Error("AI returned empty or unparseable response");
   }
   const unexpectedRootKeys = detectUnexpectedKeysFromRawText(
@@ -4906,13 +5101,14 @@ async function generateInsightsWithAI(provider, modelId, systemPrompt, userPromp
   } catch {
   }
   return {
-    result: response.output,
+    result: output,
     usage: {
       inputTokens: response.usage.inputTokens,
       outputTokens: response.usage.outputTokens,
       totalTokens: response.usage.totalTokens,
       reasoningTokens: response.usage.reasoningTokens,
-      cachedInputTokens: response.usage.cachedInputTokens
+      cachedInputTokens: response.usage.cachedInputTokens,
+      cacheWriteTokens: response.usage.inputTokenDetails?.cacheWriteTokens
     },
     unexpectedRootKeys,
     unexpectedMomentKeys,
@@ -5866,7 +6062,7 @@ async function getModerationScores(assetId, options = {}) {
 // src/workflows/summarization.ts
 import { generateText as generateText6, Output as Output6 } from "ai";
 import dedent6 from "dedent";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/lib/markdown-normalization.ts
 var ESCAPED_LINE_BREAK_REGEX = /\\r\\n|\\n|\\r/g;
@@ -5879,17 +6075,17 @@ function normalizeMarkdownDescription(description) {
 var DEFAULT_SUMMARY_KEYWORD_LIMIT = 10;
 var DEFAULT_TITLE_LENGTH = 10;
 var DEFAULT_DESCRIPTION_LENGTH = 50;
-var summarySchema = z7.object({
-  keywords: z7.array(z7.string().max(200)),
-  title: z7.string().max(500),
-  description: z7.string().max(1e4)
+var summarySchema = z8.object({
+  keywords: z8.array(z8.string().max(200)),
+  title: z8.string().max(500),
+  description: z8.string().max(1e4)
 });
 function buildSummarySchema(descriptionLength) {
   const descriptionMaxChars = Math.max(2e3, descriptionLength * 15);
-  return z7.object({
-    keywords: z7.array(z7.string().max(200)),
-    title: z7.string().max(500),
-    description: z7.string().max(descriptionMaxChars)
+  return z8.object({
+    keywords: z8.array(z8.string().max(200)),
+    title: z8.string().max(500),
+    description: z8.string().max(descriptionMaxChars)
   });
 }
 var VALID_TONES = ["neutral", "playful", "professional"];
@@ -6165,7 +6361,7 @@ async function analyzeStoryboard2(imageDataUrl, provider, modelId, userPrompt, s
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
   const schema = buildSummarySchema(descriptionLength);
-  const response = await generateText6({
+  const response = await withContentPolicyErrorHandling(() => generateText6({
     model,
     output: Output6.object({
       name: "summary_metadata",
@@ -6185,11 +6381,12 @@ async function analyzeStoryboard2(imageDataUrl, provider, modelId, userPrompt, s
         ]
       }
     ]
-  });
-  if (!response.output) {
+  }));
+  const output = getGeneratedOutputWithContentPolicyHandling(response);
+  if (!output) {
     throw new Error("Summarization output missing");
   }
-  const parsed = schema.parse(response.output);
+  const parsed = schema.parse(output);
   const unexpectedKeys = detectUnexpectedKeysFromRawText(
     response.text,
     schema.keyof().options
@@ -6201,7 +6398,8 @@ async function analyzeStoryboard2(imageDataUrl, provider, modelId, userPrompt, s
       outputTokens: response.usage.outputTokens,
       totalTokens: response.usage.totalTokens,
       reasoningTokens: response.usage.reasoningTokens,
-      cachedInputTokens: response.usage.cachedInputTokens
+      cachedInputTokens: response.usage.cachedInputTokens,
+      cacheWriteTokens: response.usage.inputTokenDetails?.cacheWriteTokens
     },
     unexpectedKeys
   };
@@ -6210,7 +6408,7 @@ async function analyzeAudioOnly(provider, modelId, userPrompt, systemPrompt, des
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
   const schema = buildSummarySchema(descriptionLength);
-  const response = await generateText6({
+  const response = await withContentPolicyErrorHandling(() => generateText6({
     model,
     output: Output6.object({
       name: "summary_metadata",
@@ -6227,11 +6425,12 @@ async function analyzeAudioOnly(provider, modelId, userPrompt, systemPrompt, des
         content: userPrompt
       }
     ]
-  });
-  if (!response.output) {
+  }));
+  const output = getGeneratedOutputWithContentPolicyHandling(response);
+  if (!output) {
     throw new Error("Summarization output missing");
   }
-  const parsed = schema.parse(response.output);
+  const parsed = schema.parse(output);
   const unexpectedKeys = detectUnexpectedKeysFromRawText(
     response.text,
     schema.keyof().options
@@ -6243,7 +6442,8 @@ async function analyzeAudioOnly(provider, modelId, userPrompt, systemPrompt, des
       outputTokens: response.usage.outputTokens,
       totalTokens: response.usage.totalTokens,
       reasoningTokens: response.usage.reasoningTokens,
-      cachedInputTokens: response.usage.cachedInputTokens
+      cachedInputTokens: response.usage.cachedInputTokens,
+      cacheWriteTokens: response.usage.inputTokenDetails?.cacheWriteTokens
     },
     unexpectedKeys
   };
@@ -6644,6 +6844,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);
@@ -6670,6 +6923,7 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
     // 0 = auto-detect
     uploadToS3: uploadToS3Option,
     uploadToMux: uploadToMuxOption,
+    uploadCaptionsToMux = false,
     storageAdapter,
     credentials: providedCredentials
   } = options;
@@ -6679,7 +6933,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;
@@ -6760,10 +7014,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,
@@ -6795,6 +7051,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 {
@@ -6804,6 +7094,8 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
     dubbingId,
     uploadedTrackId,
     presignedUrl,
+    captionsTrackId,
+    captionsPresignedUrl,
     usage: {
       metadata: {
         assetDurationSeconds
@@ -6814,16 +7106,16 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
 
 // src/workflows/translate-captions.ts
 import {
-  APICallError,
+  APICallError as APICallError2,
   generateText as generateText7,
-  NoObjectGeneratedError,
+  NoObjectGeneratedError as NoObjectGeneratedError2,
   Output as Output7,
-  RetryError,
+  RetryError as RetryError2,
   TypeValidationError
 } from "ai";
-import { z as z8 } from "zod";
-var translationSchema = z8.object({
-  translation: z8.string()
+import { z as z9 } from "zod";
+var translationSchema = z9.object({
+  translation: z9.string()
 });
 var SYSTEM_PROMPT6 = promptDedent`
   You are a subtitle translation expert. Translate VTT subtitle files to the target language specified by the user.
@@ -6890,10 +7182,10 @@ function isProviderServiceError(error) {
   if (!error) {
     return false;
   }
-  if (RetryError.isInstance(error)) {
+  if (RetryError2.isInstance(error)) {
     return isProviderServiceError(error.lastError);
   }
-  if (APICallError.isInstance(error)) {
+  if (APICallError2.isInstance(error)) {
     return true;
   }
   if (error instanceof Error && "cause" in error) {
@@ -6905,7 +7197,7 @@ function shouldSplitChunkTranslationError(error) {
   if (isProviderServiceError(error)) {
     return false;
   }
-  return NoObjectGeneratedError.isInstance(error) || TypeValidationError.isInstance(error) || isTranslationChunkValidationError(error);
+  return NoObjectGeneratedError2.isInstance(error) || TypeValidationError.isInstance(error) || isTranslationChunkValidationError(error);
 }
 function resolveTranslationChunkingOptions(options) {
   const targetChunkDurationSeconds = Math.max(
@@ -7066,7 +7358,7 @@ async function translateVttWithAI({
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
   const sanitisedVttContent = stripVttMetadataBlocks(vttContent);
-  const response = await generateText7({
+  const response = await withContentPolicyErrorHandling(() => generateText7({
     model,
     output: Output7.object({ schema: translationSchema }),
     messages: [
@@ -7081,8 +7373,9 @@ async function translateVttWithAI({
 ${sanitisedVttContent}`
       }
     ]
-  });
-  const translated = normalizeTranslatedVtt(response.output.translation);
+  }));
+  const output = getGeneratedOutputWithContentPolicyHandling(response);
+  const translated = normalizeTranslatedVtt(output.translation);
   const leakReason = detectLeakReason(translated);
   const safeTranslated = leakReason !== null ? vttContent : translated;
   if (leakReason !== null) {
@@ -7107,7 +7400,8 @@ ${sanitisedVttContent}`
       outputTokens: response.usage.outputTokens,
       totalTokens: response.usage.totalTokens,
       reasoningTokens: response.usage.reasoningTokens,
-      cachedInputTokens: response.usage.cachedInputTokens
+      cachedInputTokens: response.usage.cachedInputTokens,
+      cacheWriteTokens: response.usage.inputTokenDetails?.cacheWriteTokens
     }
   };
 }
@@ -7121,8 +7415,8 @@ async function translateCueChunkWithAI({
 }) {
   "use step";
   const model = await createLanguageModelFromConfig(provider, modelId, credentials);
-  const schema = z8.object({
-    translations: z8.array(z8.string().min(1).max(2e3)).length(cues.length)
+  const schema = z9.object({
+    translations: z9.array(z9.string().min(1).max(2e3)).length(cues.length)
   });
   const cuePayload = cues.map((cue, index) => ({
     index,
@@ -7130,7 +7424,7 @@ async function translateCueChunkWithAI({
     endTime: cue.endTime,
     text: cue.text
   }));
-  const response = await generateText7({
+  const response = await withContentPolicyErrorHandling(() => generateText7({
     model,
     output: Output7.object({ schema }),
     messages: [
@@ -7146,7 +7440,8 @@ Return exactly ${cues.length} translated cues in the same order as the input.
 ${JSON.stringify(cuePayload, null, 2)}`
       }
     ]
-  });
+  }));
+  const output = getGeneratedOutputWithContentPolicyHandling(response);
   const unexpectedKeys = detectUnexpectedKeysFromRawText(
     response.text,
     schema.keyof().options
@@ -7157,13 +7452,14 @@ ${JSON.stringify(cuePayload, null, 2)}`
     );
   }
   return {
-    translations: response.output.translations,
+    translations: output.translations,
     usage: {
       inputTokens: response.usage.inputTokens,
       outputTokens: response.usage.outputTokens,
       totalTokens: response.usage.totalTokens,
       reasoningTokens: response.usage.reasoningTokens,
-      cachedInputTokens: response.usage.cachedInputTokens
+      cachedInputTokens: response.usage.cachedInputTokens,
+      cacheWriteTokens: response.usage.inputTokenDetails?.cacheWriteTokens
     },
     unexpectedKeyCount: unexpectedKeys.length
   };
@@ -7526,6 +7822,9 @@ async function translateCaptionsInternal(assetId, trackId, toLanguageCode, optio
   };
 }
 export {
+  ASK_QUESTIONS_DEFAULT_MAX_ANSWER_OPTION_LENGTH,
+  ASK_QUESTIONS_DEFAULT_MAX_FREE_FORM_ANSWER_LENGTH,
+  ASK_QUESTIONS_MAX_QUESTION_LENGTH,
   DEFAULT_DESCRIPTION_LENGTH,
   DEFAULT_SUMMARY_KEYWORD_LIMIT,
   DEFAULT_TITLE_LENGTH,