@mux/ai 0.26.0 → 0.28.0

package/dist/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // package.json
-var version = "0.26.0";
+var version = "0.28.0";
 
 // src/lib/language-codes.ts
 var ISO639_1_TO_3 = {
@@ -560,6 +560,68 @@ function createSafetyReporter() {
   };
 }
 
+// src/lib/token-usage.ts
+var TOKEN_USAGE_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "totalTokens",
+  "reasoningTokens",
+  "cachedInputTokens"
+];
+function isDefinedTokenUsageValue(value) {
+  return typeof value === "number";
+}
+function aggregateTokenUsage(usages) {
+  return TOKEN_USAGE_FIELDS.reduce((aggregate, field) => {
+    const values = usages.map((usage) => usage[field]).filter(isDefinedTokenUsageValue);
+    if (values.length > 0) {
+      aggregate[field] = values.reduce((total, value) => total + value, 0);
+    }
+    return aggregate;
+  }, {});
+}
+function getErrorTokenUsage(error) {
+  if (typeof error !== "object" || error === null) {
+    return void 0;
+  }
+  const usage = error.usage;
+  if (typeof usage !== "object" || usage === null) {
+    return void 0;
+  }
+  const source = usage;
+  const extracted = {};
+  for (const field of TOKEN_USAGE_FIELDS) {
+    const value = source[field];
+    if (typeof value === "number") {
+      extracted[field] = value;
+    }
+  }
+  if (extracted.reasoningTokens === void 0) {
+    const reasoningTokens = source.outputTokenDetails?.reasoningTokens;
+    if (typeof reasoningTokens === "number") {
+      extracted.reasoningTokens = reasoningTokens;
+    }
+  }
+  if (extracted.cachedInputTokens === void 0) {
+    const cacheReadTokens = source.inputTokenDetails?.cacheReadTokens;
+    if (typeof cacheReadTokens === "number") {
+      extracted.cachedInputTokens = cacheReadTokens;
+    }
+  }
+  return Object.keys(extracted).length > 0 ? extracted : void 0;
+}
+function rethrowWithTokenUsage(error, collectedUsage) {
+  const usages = [...collectedUsage];
+  const errorUsage = getErrorTokenUsage(error);
+  if (errorUsage) {
+    usages.push(errorUsage);
+  }
+  if (usages.length > 0 && typeof error === "object" && error !== null) {
+    error.usage = aggregateTokenUsage(usages);
+  }
+  throw error;
+}
+
 // src/lib/mux-ai-error.ts
 var MuxAiError = class extends Error {
   constructor(message, opts) {
@@ -572,18 +634,38 @@ var MuxAiError = class extends Error {
     this.retryable = opts?.retryable ?? false;
   }
 };
+function extractErrorDetail(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  if (typeof error === "string" && error.length > 0) {
+    return error;
+  }
+  if (typeof error === "object" && error !== null) {
+    const message = error.message;
+    if (typeof message === "string" && message.length > 0) {
+      return message;
+    }
+  }
+  return "Unknown error";
+}
 function wrapError(error, message) {
   if (error instanceof MuxAiError) {
     throw error;
   }
-  const rawDetail = error instanceof Error ? error.message : "Unknown error";
+  const rawDetail = extractErrorDetail(error);
   const leakReason = detectLeakReason(rawDetail);
   const shouldSuppress = leakReason === "canary" || leakReason === "prompt_tag";
   const detail = shouldSuppress ? "Upstream error details suppressed by safety filter" : rawDetail;
   if (shouldSuppress) {
     console.warn(`[@mux/ai] Suppressed suspected prompt leak in wrapped error (context: ${message}, reason: ${leakReason}).`);
   }
-  throw new Error(`${message}: ${detail}`);
+  const wrapped = new Error(`${message}: ${detail}`);
+  const usage = getErrorTokenUsage(error);
+  if (usage) {
+    wrapped.usage = usage;
+  }
+  throw wrapped;
 }
 
 // src/lib/workflow-crypto.ts
@@ -1329,7 +1411,7 @@ var DEFAULT_EMBEDDING_MODELS = {
 var LANGUAGE_MODELS = {
   openai: ["gpt-5.1", "gpt-5-mini"],
   anthropic: ["claude-sonnet-4-5"],
-  google: ["gemini-3-flash-preview", "gemini-3.1-flash-lite", "gemini-3.1-flash-lite-preview", "gemini-2.5-flash"]
+  google: ["gemini-3-flash-preview", "gemini-3.1-flash-lite", "gemini-2.5-flash"]
 };
 var LANGUAGE_MODEL_DEPRECATIONS = [
   {
@@ -1345,10 +1427,10 @@ var LANGUAGE_MODEL_DEPRECATIONS = [
     provider: "google",
     modelId: "gemini-3.1-flash-lite-preview",
     replacementModelId: "gemini-3.1-flash-lite",
-    phase: "warn",
+    phase: "blocked",
     deprecatedOn: "2026-05-12",
     sunsetOn: "2026-05-25",
-    reason: "Preview model graduated to the stable Gemini 3.1 Flash-Lite release."
+    reason: "Google shut down Gemini 3.1 Flash-Lite Preview on 2026-05-25."
   }
 ];
 var warnedDeprecatedLanguageModels = /* @__PURE__ */ new Set();
@@ -3286,6 +3368,14 @@ async function analyzeQuestions({
 }
 async function askQuestions(assetId, questions, options) {
   "use workflow";
+  const collectedUsage = [];
+  try {
+    return await askQuestionsInternal(assetId, questions, options, collectedUsage);
+  } catch (error) {
+    rethrowWithTokenUsage(error, collectedUsage);
+  }
+}
+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" });
   }
@@ -3434,6 +3524,7 @@ async function askQuestions(assetId, questions, options) {
     const contentType = isAudioOnly ? "audio" : "video";
     wrapError(error, `Failed to analyze ${contentType} questions with ${provider}`);
   }
+  collectedUsage.push(analysisResponse.usage);
   if (!analysisResponse.result?.answers) {
     throw new MuxAiError(`Failed to generate answers for asset ${assetId}.`);
   }
@@ -3667,6 +3758,14 @@ async function analyzeStoryboard({
 }
 async function hasBurnedInCaptions(assetId, options = {}) {
   "use workflow";
+  const collectedUsage = [];
+  try {
+    return await hasBurnedInCaptionsInternal(assetId, options, collectedUsage);
+  } catch (error) {
+    rethrowWithTokenUsage(error, collectedUsage);
+  }
+}
+async function hasBurnedInCaptionsInternal(assetId, options, collectedUsage) {
   const {
     provider = DEFAULT_PROVIDER,
     model,
@@ -3706,6 +3805,7 @@ async function hasBurnedInCaptions(assetId, options = {}) {
       credentials
     });
   }
+  collectedUsage.push(analysisResponse.usage);
   if (!analysisResponse.result) {
     throw new Error("No analysis result received from AI provider");
   }
@@ -3907,6 +4007,14 @@ function buildUserPrompt3({
 }
 async function generateChapters(assetId, options = {}) {
   "use workflow";
+  const collectedUsage = [];
+  try {
+    return await generateChaptersInternal(assetId, options, collectedUsage);
+  } catch (error) {
+    rethrowWithTokenUsage(error, collectedUsage);
+  }
+}
+async function generateChaptersInternal(assetId, options, collectedUsage) {
   const {
     languageCode,
     provider = "openai",
@@ -3974,6 +4082,9 @@ async function generateChapters(assetId, options = {}) {
   } catch (error) {
     wrapError(error, `Failed to generate chapters with ${provider}`);
   }
+  if (chaptersData) {
+    collectedUsage.push(chaptersData.usage);
+  }
   if (!chaptersData || !chaptersData.chapters) {
     throw new MuxAiError(`Failed to generate chapters for asset ${assetId}.`);
   }
@@ -4348,6 +4459,14 @@ async function deleteTrackOnMux(assetId, trackId, credentials) {
 }
 async function editCaptions(assetId, trackId, options) {
   "use workflow";
+  const collectedUsage = [];
+  try {
+    return await editCaptionsInternal(assetId, trackId, options, collectedUsage);
+  } catch (error) {
+    rethrowWithTokenUsage(error, collectedUsage);
+  }
+}
+async function editCaptionsInternal(assetId, trackId, options, collectedUsage) {
   const {
     provider,
     model,
@@ -4436,6 +4555,7 @@ async function editCaptions(assetId, trackId, options) {
       });
       detectedProfanity = result.profanity;
       usage = result.usage;
+      collectedUsage.push(result.usage);
       if (result.unexpectedKeys.length > 0) {
         console.warn(
           `[@mux/ai] Model emitted unexpected keys in profanity detection (stripped): ${result.unexpectedKeys.join(", ")}.`
@@ -4556,16 +4676,19 @@ async function generateSingleChunkEmbedding({
     })
   );
   return {
-    chunkId: chunk.id,
-    embedding: response.embedding,
-    metadata: {
-      startTime: chunk.startTime,
-      endTime: chunk.endTime,
-      tokenCount: chunk.tokenCount
-    }
+    chunk: {
+      chunkId: chunk.id,
+      embedding: response.embedding,
+      metadata: {
+        startTime: chunk.startTime,
+        endTime: chunk.endTime,
+        tokenCount: chunk.tokenCount
+      }
+    },
+    usage: typeof response.usage?.tokens === "number" ? { inputTokens: response.usage.tokens, totalTokens: response.usage.tokens } : void 0
   };
 }
-async function generateEmbeddingsInternal(assetId, options = {}) {
+async function generateEmbeddingsInternal(assetId, options, collectedUsage) {
   const {
     provider = "openai",
     model,
@@ -4604,7 +4727,7 @@ async function generateEmbeddingsInternal(assetId, options = {}) {
   try {
     for (let i = 0; i < chunks.length; i += batchSize) {
       const batch = chunks.slice(i, i + batchSize);
-      const batchResults = await Promise.all(
+      const batchOutcomes = await Promise.allSettled(
         batch.map(
           (chunk) => generateSingleChunkEmbedding({
             chunk,
@@ -4614,7 +4737,24 @@ async function generateEmbeddingsInternal(assetId, options = {}) {
           })
         )
       );
-      chunkEmbeddings.push(...batchResults);
+      const failures = [];
+      for (const outcome of batchOutcomes) {
+        if (outcome.status === "fulfilled") {
+          if (outcome.value.usage) {
+            collectedUsage.push(outcome.value.usage);
+          }
+          chunkEmbeddings.push(outcome.value.chunk);
+        } else {
+          const failureUsage = getErrorTokenUsage(outcome.reason);
+          if (failureUsage) {
+            collectedUsage.push(failureUsage);
+          }
+          failures.push(outcome.reason);
+        }
+      }
+      if (failures.length > 0) {
+        throw failures[0];
+      }
     }
   } catch (error) {
     throw new Error(
@@ -4648,12 +4788,22 @@ async function generateEmbeddingsInternal(assetId, options = {}) {
 }
 async function generateEmbeddings(assetId, options = {}) {
   "use workflow";
-  return generateEmbeddingsInternal(assetId, options);
+  const collectedUsage = [];
+  try {
+    return await generateEmbeddingsInternal(assetId, options, collectedUsage);
+  } catch (error) {
+    rethrowWithTokenUsage(error, collectedUsage);
+  }
 }
 async function generateVideoEmbeddings(assetId, options = {}) {
   "use workflow";
   console.warn("generateVideoEmbeddings is deprecated. Use generateEmbeddings instead.");
-  return generateEmbeddingsInternal(assetId, options);
+  const collectedUsage = [];
+  try {
+    return await generateEmbeddingsInternal(assetId, options, collectedUsage);
+  } catch (error) {
+    rethrowWithTokenUsage(error, collectedUsage);
+  }
 }
 
 // src/workflows/engagement-insights.ts
@@ -4992,6 +5142,14 @@ async function generateInsightsWithAI(provider, modelId, systemPrompt, userPromp
 }
 async function generateEngagementInsights(assetId, options = {}) {
   "use workflow";
+  const collectedUsage = [];
+  try {
+    return await generateEngagementInsightsInternal(assetId, options, collectedUsage);
+  } catch (error) {
+    rethrowWithTokenUsage(error, collectedUsage);
+  }
+}
+async function generateEngagementInsightsInternal(assetId, options, collectedUsage) {
   const {
     provider = "openai",
     model,
@@ -5118,6 +5276,7 @@ async function generateEngagementInsights(assetId, options = {}) {
     credentials
   );
   const { result: aiInsights, usage } = aiStepResult;
+  collectedUsage.push(usage);
   if (!aiInsights.momentInsights || aiInsights.momentInsights.length === 0) {
     throw new MuxAiError(`Failed to generate insights for asset ${assetId}.`);
   }
@@ -6267,6 +6426,14 @@ function normalizeKeywords(keywords, limit = DEFAULT_SUMMARY_KEYWORD_LIMIT) {
 }
 async function getSummaryAndTags(assetId, options) {
   "use workflow";
+  const collectedUsage = [];
+  try {
+    return await getSummaryAndTagsInternal(assetId, options, collectedUsage);
+  } catch (error) {
+    rethrowWithTokenUsage(error, collectedUsage);
+  }
+}
+async function getSummaryAndTagsInternal(assetId, options, collectedUsage) {
   const {
     provider = "openai",
     model,
@@ -6376,6 +6543,7 @@ async function getSummaryAndTags(assetId, options) {
     const contentType = isAudioOnly ? "audio" : "video";
     wrapError(error, `Failed to analyze ${contentType} content with ${provider}`);
   }
+  collectedUsage.push(analysisResponse.usage);
   if (!analysisResponse.result) {
     const contentType = isAudioOnly ? "audio" : "video";
     throw new MuxAiError(`Failed to analyze ${contentType} content for asset ${assetId}.`);
@@ -6418,12 +6586,11 @@ async function getSummaryAndTags(assetId, options) {
 }
 
 // src/workflows/translate-audio.ts
+import { sleep as sleep2 } from "workflow";
 var STATIC_RENDITION_POLL_INTERVAL_MS = 5e3;
 var STATIC_RENDITION_MAX_ATTEMPTS = 36;
-async function sleep2(ms) {
-  "use step";
-  await new Promise((resolve) => setTimeout(resolve, ms));
-}
+var DUBBING_POLL_INTERVAL_MS = 1e4;
+var DEFAULT_DUBBING_POLL_TIMEOUT_SECONDS = 7200;
 function getReadyAudioStaticRendition(asset) {
   const files = asset.static_renditions?.files;
   if (!files || files.length === 0) {
@@ -6464,14 +6631,17 @@ async function requestStaticRenditionCreation(assetId, credentials) {
     wrapError(error, "Failed to request static rendition from Mux");
   }
 }
+async function retrieveAsset(assetId, credentials) {
+  "use step";
+  const muxClient = await resolveMuxClient(credentials);
+  const mux = await muxClient.createClient();
+  return mux.video.assets.retrieve(assetId);
+}
 async function waitForAudioStaticRendition({
   assetId,
   initialAsset,
   credentials
 }) {
-  "use step";
-  const muxClient = await resolveMuxClient(credentials);
-  const mux = await muxClient.createClient();
   let currentAsset = initialAsset;
   if (hasReadyAudioStaticRendition(currentAsset)) {
     return currentAsset;
@@ -6486,7 +6656,7 @@ async function waitForAudioStaticRendition({
   }
   for (let attempt = 1; attempt <= STATIC_RENDITION_MAX_ATTEMPTS; attempt++) {
     await sleep2(STATIC_RENDITION_POLL_INTERVAL_MS);
-    currentAsset = await mux.video.assets.retrieve(assetId);
+    currentAsset = await retrieveAsset(assetId, credentials);
     if (hasReadyAudioStaticRendition(currentAsset)) {
       return currentAsset;
     }
@@ -6505,16 +6675,8 @@ async function waitForAudioStaticRendition({
     { type: "timeout_error", retryable: true }
   );
 }
-async function fetchAudioFromMux(audioUrl) {
-  "use step";
-  const audioResponse = await fetch(audioUrl);
-  if (!audioResponse.ok) {
-    throw new Error(`Failed to fetch audio file: ${audioResponse.statusText}`);
-  }
-  return audioResponse.arrayBuffer();
-}
 async function createElevenLabsDubbingJob({
-  audioBuffer,
+  sourceUrl,
   assetId,
   elevenLabsLangCode,
   elevenLabsSourceLangCode,
@@ -6523,9 +6685,8 @@ async function createElevenLabsDubbingJob({
 }) {
   "use step";
   const elevenLabsApiKey = await getApiKeyFromEnv("elevenlabs", credentials);
-  const audioBlob = new Blob([audioBuffer], { type: "audio/mp4" });
   const formData = new FormData();
-  formData.append("file", audioBlob);
+  formData.append("source_url", sourceUrl);
   formData.append("target_lang", elevenLabsLangCode);
   if (elevenLabsSourceLangCode) {
     formData.append("source_lang", elevenLabsSourceLangCode);
@@ -6690,13 +6851,6 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
   if (policy === "signed") {
     audioUrl = await signUrl(audioUrl, playbackId, "video", void 0, credentials);
   }
-  console.warn("\u{1F399}\uFE0F Fetching audio from Mux...");
-  let audioBuffer;
-  try {
-    audioBuffer = await fetchAudioFromMux(audioUrl);
-  } catch (error) {
-    wrapError(error, "Failed to fetch audio from Mux");
-  }
   console.warn("\u{1F399}\uFE0F Creating dubbing job in ElevenLabs...");
   const elevenLabsLangCode = toISO639_3(toLanguageCode);
   const normalizedFromLanguageCode = fromLanguageCode?.trim();
@@ -6707,7 +6861,7 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
   let dubbingId;
   try {
     dubbingId = await createElevenLabsDubbingJob({
-      audioBuffer,
+      sourceUrl: audioUrl,
       assetId,
       elevenLabsLangCode,
       elevenLabsSourceLangCode,
@@ -6719,12 +6873,13 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
     wrapError(error, "Failed to create ElevenLabs dubbing job");
   }
   console.warn("\u23F3 Waiting for dubbing to complete...");
+  const dubbingPollTimeoutSeconds = options.dubbingPollTimeoutSeconds ?? DEFAULT_DUBBING_POLL_TIMEOUT_SECONDS;
+  const maxPollAttempts = Math.max(1, Math.ceil(dubbingPollTimeoutSeconds * 1e3 / DUBBING_POLL_INTERVAL_MS));
   let dubbingStatus = "dubbing";
   let pollAttempts = 0;
-  const maxPollAttempts = 180;
   let targetLanguages = [];
-  while (dubbingStatus === "dubbing" && pollAttempts < maxPollAttempts) {
-    await sleep2(1e4);
+  while (dubbingStatus !== "dubbed" && pollAttempts < maxPollAttempts) {
+    await sleep2(DUBBING_POLL_INTERVAL_MS);
     pollAttempts++;
     try {
       const statusResult = await checkElevenLabsDubbingStatus({
@@ -6733,12 +6888,12 @@ async function translateAudio(assetId, toLanguageCode, options = {}) {
       });
       dubbingStatus = statusResult.status;
       targetLanguages = statusResult.targetLanguages;
-      if (dubbingStatus === "failed") {
-        throw new Error("ElevenLabs dubbing job failed");
-      }
     } catch (error) {
       wrapError(error, "Failed to check dubbing status");
     }
+    if (dubbingStatus === "failed") {
+      throw new MuxAiError("ElevenLabs reported that the dubbing job failed.", { type: "processing_error" });
+    }
   }
   if (dubbingStatus !== "dubbed") {
     throw new MuxAiError("Audio translation timed out or failed. Please try again.", { type: "timeout_error", retryable: true });
@@ -6885,13 +7040,6 @@ var DEFAULT_TRANSLATION_CHUNKING = {
   maxCuesPerChunk: 80,
   maxCueTextTokensPerChunk: 2e3
 };
-var TOKEN_USAGE_FIELDS = [
-  "inputTokens",
-  "outputTokens",
-  "totalTokens",
-  "reasoningTokens",
-  "cachedInputTokens"
-];
 var TranslationChunkValidationError = class extends Error {
   constructor(message) {
     super(message);
@@ -6922,9 +7070,6 @@ function shouldSplitChunkTranslationError(error) {
   }
   return NoObjectGeneratedError.isInstance(error) || TypeValidationError.isInstance(error) || isTranslationChunkValidationError(error);
 }
-function isDefinedTokenUsageValue(value) {
-  return typeof value === "number";
-}
 function resolveTranslationChunkingOptions(options) {
   const targetChunkDurationSeconds = Math.max(
     1,
@@ -6951,14 +7096,27 @@ function resolveTranslationChunkingOptions(options) {
     )
   };
 }
-function aggregateTokenUsage(usages) {
-  return TOKEN_USAGE_FIELDS.reduce((aggregate, field) => {
-    const values = usages.map((usage) => usage[field]).filter(isDefinedTokenUsageValue);
-    if (values.length > 0) {
-      aggregate[field] = values.reduce((total, value) => total + value, 0);
+function collectSettledTranslationsOrRethrow(outcomes, priorUsage) {
+  const results = [];
+  const failures = [];
+  for (const outcome of outcomes) {
+    if (outcome.status === "fulfilled") {
+      results.push(outcome.value);
+    } else {
+      failures.push(outcome.reason);
     }
-    return aggregate;
-  }, {});
+  }
+  if (failures.length > 0) {
+    const partialUsage = [...priorUsage, ...results.map((result) => result.usage)];
+    for (const failure of failures.slice(1)) {
+      const usage = getErrorTokenUsage(failure);
+      if (usage) {
+        partialUsage.push(usage);
+      }
+    }
+    rethrowWithTokenUsage(failures[0], partialUsage);
+  }
+  return results;
 }
 function createTranslationChunkRequest(id, cues, cueBlocks) {
   return {
@@ -7234,24 +7392,28 @@ async function translateChunkWithFallback({
       wrapError(error, `Chunk ${chunk.id} failed for ${Math.round(chunk.startTime)}s-${Math.round(chunk.endTime)}s`);
     }
     const [leftChunk, rightChunk] = splitTranslationChunkAtMidpoint(chunk);
-    const [leftResult, rightResult] = await Promise.all([
-      translateChunkWithFallback({
-        chunk: leftChunk,
-        fromLanguageCode,
-        toLanguageCode,
-        provider,
-        modelId,
-        credentials
-      }),
-      translateChunkWithFallback({
-        chunk: rightChunk,
-        fromLanguageCode,
-        toLanguageCode,
-        provider,
-        modelId,
-        credentials
-      })
-    ]);
+    const failedAttemptUsage = getErrorTokenUsage(error);
+    const [leftResult, rightResult] = collectSettledTranslationsOrRethrow(
+      await Promise.allSettled([
+        translateChunkWithFallback({
+          chunk: leftChunk,
+          fromLanguageCode,
+          toLanguageCode,
+          provider,
+          modelId,
+          credentials
+        }),
+        translateChunkWithFallback({
+          chunk: rightChunk,
+          fromLanguageCode,
+          toLanguageCode,
+          provider,
+          modelId,
+          credentials
+        })
+      ]),
+      failedAttemptUsage ? [failedAttemptUsage] : []
+    );
     return {
       translatedVtt: concatenateVttSegments([leftResult.translatedVtt, rightResult.translatedVtt]),
       usage: aggregateTokenUsage([leftResult.usage, rightResult.usage]),
@@ -7292,17 +7454,20 @@ async function translateCaptionTrack({
   let totalUnexpectedKeyCount = 0;
   for (let index = 0; index < chunkPlan.chunks.length; index += resolvedChunking.maxConcurrentTranslations) {
     const batch = chunkPlan.chunks.slice(index, index + resolvedChunking.maxConcurrentTranslations);
-    const batchResults = await Promise.all(
-      batch.map(
-        (chunk) => translateChunkWithFallback({
-          chunk,
-          fromLanguageCode,
-          toLanguageCode,
-          provider,
-          modelId,
-          credentials
-        })
-      )
+    const batchResults = collectSettledTranslationsOrRethrow(
+      await Promise.allSettled(
+        batch.map(
+          (chunk) => translateChunkWithFallback({
+            chunk,
+            fromLanguageCode,
+            toLanguageCode,
+            provider,
+            modelId,
+            credentials
+          })
+        )
+      ),
+      usageByChunk
     );
     translatedSegments.push(...batchResults.map((result) => result.translatedVtt));
     usageByChunk.push(...batchResults.map((result) => result.usage));
@@ -7355,6 +7520,14 @@ async function uploadVttToS3({
 }
 async function translateCaptions(assetId, trackId, toLanguageCode, options) {
   "use workflow";
+  const collectedUsage = [];
+  try {
+    return await translateCaptionsInternal(assetId, trackId, toLanguageCode, options, collectedUsage);
+  } catch (error) {
+    rethrowWithTokenUsage(error, collectedUsage);
+  }
+}
+async function translateCaptionsInternal(assetId, trackId, toLanguageCode, options, collectedUsage) {
   const {
     provider = "openai",
     model,
@@ -7433,6 +7606,7 @@ async function translateCaptions(assetId, trackId, toLanguageCode, options) {
     });
     translatedVtt = result.translatedVtt;
     usage = result.usage;
+    collectedUsage.push(result.usage);
     scrubbedCueCounts = result.scrubbedCueCounts;
     unexpectedKeyCount = result.unexpectedKeyCount;
   } catch (error) {