@mux/ai 0.1.1 → 0.1.2

package/dist/index.js

@@ -1,9 +1,1758 @@
-export * from './types';
-export * from './moderation';
-export * from './summarization';
-export * from './translation';
-export * from './audio-translation';
-export * from './chapters';
-export * from './burned-in-captions';
-export const version = '0.1.0';
+import pRetry, { AbortError } from 'p-retry';
+import Mux from '@mux/mux-node';
+import OpenAI from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
+import { z } from 'zod';
+import { zodTextFormat } from 'openai/helpers/zod';
+import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
+import { Upload } from '@aws-sdk/lib-storage';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/image-download.ts
+var image_download_exports = {};
+__export(image_download_exports, {
+  downloadImageAsBase64: () => downloadImageAsBase64,
+  downloadImagesAsBase64: () => downloadImagesAsBase64,
+  uploadImageToAnthropicFiles: () => uploadImageToAnthropicFiles
+});
+async function downloadImageAsBase64(url, options = {}) {
+  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 = Buffer.from(arrayBuffer);
+        if (buffer.length === 0) {
+          throw new AbortError("Downloaded image is empty");
+        }
+        const base64Data = `data:${contentType};base64,${buffer.toString("base64")}`;
+        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) {
+  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;
+}
+async function uploadImageToAnthropicFiles(url, anthropicApiKey, options = {}) {
+  const downloadResult = await downloadImageAsBase64(url, options);
+  const formData = new FormData();
+  const imageBlob = new Blob([downloadResult.buffer], {
+    type: downloadResult.contentType
+  });
+  const extension = downloadResult.contentType.split("/")[1] || "png";
+  formData.append("file", imageBlob, `image.${extension}`);
+  const response = await fetch("https://api.anthropic.com/v1/files", {
+    method: "POST",
+    headers: {
+      "x-api-key": anthropicApiKey,
+      "anthropic-version": "2023-06-01",
+      "anthropic-beta": "files-api-2025-04-14"
+      // Don't set Content-Type header - let fetch set it with boundary for multipart
+    },
+    body: formData
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Anthropic Files API error: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  const fileResult = await response.json();
+  return {
+    fileId: fileResult.id,
+    url: downloadResult.url,
+    contentType: downloadResult.contentType,
+    sizeBytes: downloadResult.sizeBytes
+  };
+}
+var DEFAULT_OPTIONS;
+var init_image_download = __esm({
+  "src/utils/image-download.ts"() {
+    DEFAULT_OPTIONS = {
+      timeout: 1e4,
+      retries: 3,
+      retryDelay: 1e3,
+      maxRetryDelay: 1e4,
+      exponentialBackoff: true
+    };
+  }
+});
+
+// src/moderation.ts
+init_image_download();
+var DEFAULT_THRESHOLDS = {
+  sexual: 0.7,
+  violence: 0.8
+};
+async function processConcurrently(items, processor, maxConcurrent = 5) {
+  const results = [];
+  for (let i = 0; i < items.length; i += maxConcurrent) {
+    const batch = items.slice(i, i + maxConcurrent);
+    const batchPromises = batch.map(processor);
+    const batchResults = await Promise.all(batchPromises);
+    results.push(...batchResults);
+  }
+  return results;
+}
+var HIVE_SEXUAL_CATEGORIES = [
+  "general_nsfw",
+  "general_suggestive",
+  "yes_sexual_activity",
+  "female_underwear",
+  "male_underwear",
+  "bra",
+  "panties",
+  "sex_toys",
+  "nudity_female",
+  "nudity_male",
+  "cleavage",
+  "swimwear"
+];
+var HIVE_VIOLENCE_CATEGORIES = [
+  "gun_in_hand",
+  "gun_not_in_hand",
+  "animated_gun",
+  "knife_in_hand",
+  "knife_not_in_hand",
+  "culinary_knife_not_in_hand",
+  "culinary_knife_in_hand",
+  "very_bloody",
+  "a_little_bloody",
+  "other_blood",
+  "hanging",
+  "noose",
+  "human_corpse",
+  "animated_corpse",
+  "emaciated_body",
+  "self_harm",
+  "animal_abuse",
+  "fights",
+  "garm_death_injury_or_military_conflict"
+];
+function getThumbnailUrls(playbackId, duration, options = {}) {
+  const { interval = 10, width = 640 } = options;
+  const timestamps = [];
+  if (duration <= 50) {
+    const spacing = duration / 6;
+    for (let i = 1; i <= 5; i++) {
+      timestamps.push(Math.round(i * spacing));
+    }
+  } else {
+    for (let time = 0; time < duration; time += interval) {
+      timestamps.push(time);
+    }
+  }
+  return timestamps.map(
+    (time) => `https://image.mux.com/${playbackId}/thumbnail.png?time=${time}&width=${width}`
+  );
+}
+async function requestOpenAIModeration(imageUrls, openaiClient, model, maxConcurrent = 5, submissionMode = "url", downloadOptions) {
+  if (submissionMode === "base64") {
+    try {
+      const downloadResults = await downloadImagesAsBase64(imageUrls, downloadOptions, maxConcurrent);
+      const processor2 = async (downloadResult) => {
+        try {
+          const moderation = await openaiClient.moderations.create({
+            model,
+            input: [
+              {
+                type: "image_url",
+                image_url: {
+                  url: downloadResult.base64Data
+                  // Use base64 data URI
+                }
+              }
+            ]
+          });
+          const categoryScores = moderation.results[0].category_scores;
+          return {
+            url: downloadResult.url,
+            // Return original URL for tracking
+            sexual: categoryScores.sexual || 0,
+            violence: categoryScores.violence || 0,
+            error: false
+          };
+        } catch (error) {
+          console.error(`Failed to moderate downloaded image ${downloadResult.url}:`, error);
+          return {
+            url: downloadResult.url,
+            sexual: 0,
+            violence: 0,
+            error: true
+          };
+        }
+      };
+      return processConcurrently(downloadResults, processor2, maxConcurrent);
+    } catch (error) {
+      console.error("Failed to download images for base64 submission:", error);
+      return imageUrls.map((url) => ({
+        url,
+        sexual: 0,
+        violence: 0,
+        error: true
+      }));
+    }
+  }
+  const processor = async (url) => {
+    try {
+      const moderation = await openaiClient.moderations.create({
+        model,
+        input: [
+          {
+            type: "image_url",
+            image_url: {
+              url
+            }
+          }
+        ]
+      });
+      const categoryScores = moderation.results[0].category_scores;
+      return {
+        url,
+        sexual: categoryScores.sexual || 0,
+        violence: categoryScores.violence || 0,
+        error: false
+      };
+    } catch (error) {
+      console.error("Failed to moderate image:", error);
+      return {
+        url,
+        sexual: 0,
+        violence: 0,
+        error: true
+      };
+    }
+  };
+  return processConcurrently(imageUrls, processor, maxConcurrent);
+}
+async function requestHiveModeration(imageUrls, hiveApiKey, maxConcurrent = 5, submissionMode = "url", downloadOptions) {
+  if (submissionMode === "base64") {
+    try {
+      const downloadResults = await downloadImagesAsBase64(imageUrls, downloadOptions, maxConcurrent);
+      const processor2 = async (downloadResult) => {
+        try {
+          const formData = new FormData();
+          const imageBlob = new Blob([downloadResult.buffer], {
+            type: downloadResult.contentType
+          });
+          const extension = downloadResult.contentType.split("/")[1] || "png";
+          formData.append("media", imageBlob, `image.${extension}`);
+          const response = await fetch("https://api.thehive.ai/api/v2/task/sync", {
+            method: "POST",
+            headers: {
+              "Authorization": `Token ${hiveApiKey}`
+              // Don't set Content-Type header - let fetch set it with boundary for multipart
+            },
+            body: formData
+          });
+          if (!response.ok) {
+            throw new Error(`Hive API error: ${response.statusText}`);
+          }
+          const hiveResult = await response.json();
+          const classes = hiveResult.status?.[0]?.response?.output?.[0]?.classes || [];
+          const scoreMap = Object.fromEntries(classes.map((c) => [c.class, c.score]));
+          const sexualScores = HIVE_SEXUAL_CATEGORIES.map(
+            (category) => scoreMap[category] || 0
+          );
+          const violenceScores = HIVE_VIOLENCE_CATEGORIES.map(
+            (category) => scoreMap[category] || 0
+          );
+          return {
+            url: downloadResult.url,
+            // Return original URL for tracking
+            sexual: Math.max(...sexualScores, 0),
+            violence: Math.max(...violenceScores, 0),
+            error: false
+          };
+        } catch (error) {
+          console.error(`Failed to moderate uploaded image ${downloadResult.url}:`, error);
+          return {
+            url: downloadResult.url,
+            sexual: 0,
+            violence: 0,
+            error: true
+          };
+        }
+      };
+      return processConcurrently(downloadResults, processor2, maxConcurrent);
+    } catch (error) {
+      console.error("Failed to download images for Hive multipart upload:", error);
+      return imageUrls.map((url) => ({
+        url,
+        sexual: 0,
+        violence: 0,
+        error: true
+      }));
+    }
+  }
+  const processor = async (url) => {
+    try {
+      const response = await fetch("https://api.thehive.ai/api/v2/task/sync", {
+        method: "POST",
+        headers: {
+          "Authorization": `Token ${hiveApiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ url })
+      });
+      if (!response.ok) {
+        throw new Error(`Hive API error: ${response.statusText}`);
+      }
+      const hiveResult = await response.json();
+      const classes = hiveResult.status?.[0]?.response?.output?.[0]?.classes || [];
+      const scoreMap = Object.fromEntries(classes.map((c) => [c.class, c.score]));
+      const sexualScores = HIVE_SEXUAL_CATEGORIES.map(
+        (category) => scoreMap[category] || 0
+      );
+      const violenceScores = HIVE_VIOLENCE_CATEGORIES.map(
+        (category) => scoreMap[category] || 0
+      );
+      return {
+        url,
+        sexual: Math.max(...sexualScores, 0),
+        violence: Math.max(...violenceScores, 0),
+        error: false
+      };
+    } catch (error) {
+      console.error("Failed to moderate image with Hive:", error);
+      return {
+        url,
+        sexual: 0,
+        violence: 0,
+        error: true
+      };
+    }
+  };
+  return processConcurrently(imageUrls, processor, maxConcurrent);
+}
+async function getModerationScores(assetId, options = {}) {
+  const {
+    provider = "openai",
+    model = "omni-moderation-latest",
+    thresholds = DEFAULT_THRESHOLDS,
+    thumbnailInterval = 10,
+    thumbnailWidth = 640,
+    maxConcurrent = 5,
+    imageSubmissionMode = "url",
+    imageDownloadOptions,
+    muxTokenId,
+    muxTokenSecret,
+    openaiApiKey,
+    ...config
+  } = options;
+  if (provider !== "openai" && provider !== "hive") {
+    throw new Error("Only OpenAI and Hive providers are currently supported");
+  }
+  const muxId = muxTokenId || process.env.MUX_TOKEN_ID;
+  const muxSecret = muxTokenSecret || process.env.MUX_TOKEN_SECRET;
+  const openaiKey = openaiApiKey || process.env.OPENAI_API_KEY;
+  const hiveKey = options.hiveApiKey || process.env.HIVE_API_KEY;
+  if (!muxId || !muxSecret) {
+    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
+  }
+  if (provider === "openai" && !openaiKey) {
+    throw new Error("OpenAI API key is required for OpenAI provider. Provide openaiApiKey in options or set OPENAI_API_KEY environment variable.");
+  }
+  if (provider === "hive" && !hiveKey) {
+    throw new Error("Hive API key is required for Hive provider. Provide hiveApiKey in options or set HIVE_API_KEY environment variable.");
+  }
+  const mux = new Mux({
+    tokenId: muxId,
+    tokenSecret: muxSecret
+  });
+  let openaiClient;
+  if (provider === "openai") {
+    openaiClient = new OpenAI({
+      apiKey: openaiKey
+    });
+  }
+  let assetData;
+  try {
+    const asset = await mux.video.assets.retrieve(assetId);
+    assetData = asset;
+  } catch (error) {
+    throw new Error(`Failed to fetch asset from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  const publicPlaybackIds = assetData.playback_ids?.filter((pid) => pid.policy === "public") || [];
+  if (publicPlaybackIds.length === 0) {
+    throw new Error("No public playback IDs found for this asset. Moderation requires public playback access.");
+  }
+  const playbackId = publicPlaybackIds[0].id;
+  const duration = assetData.duration || 0;
+  const thumbnailUrls = getThumbnailUrls(playbackId, duration, {
+    interval: thumbnailInterval,
+    width: thumbnailWidth
+  });
+  let thumbnailScores;
+  if (provider === "openai") {
+    thumbnailScores = await requestOpenAIModeration(
+      thumbnailUrls,
+      openaiClient,
+      model,
+      maxConcurrent,
+      imageSubmissionMode,
+      imageDownloadOptions
+    );
+  } else if (provider === "hive") {
+    thumbnailScores = await requestHiveModeration(
+      thumbnailUrls,
+      hiveKey,
+      maxConcurrent,
+      imageSubmissionMode,
+      imageDownloadOptions
+    );
+  } else {
+    throw new Error("Unsupported provider");
+  }
+  const maxSexual = Math.max(...thumbnailScores.map((s) => s.sexual));
+  const maxViolence = Math.max(...thumbnailScores.map((s) => s.violence));
+  const finalThresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
+  return {
+    assetId,
+    thumbnailScores,
+    maxScores: {
+      sexual: maxSexual,
+      violence: maxViolence
+    },
+    exceedsThreshold: maxSexual > finalThresholds.sexual || maxViolence > finalThresholds.violence,
+    thresholds: finalThresholds
+  };
+}
+
+// src/summarization.ts
+init_image_download();
+
+// src/utils/vtt-parser.ts
+function extractTextFromVTT(vttContent) {
+  if (!vttContent.trim()) {
+    return "";
+  }
+  const lines = vttContent.split("\n");
+  const textLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    if (line === "WEBVTT") continue;
+    if (line.startsWith("NOTE ")) continue;
+    if (line.includes("-->")) continue;
+    if (/^[\d\w-]+$/.test(line) && !line.includes(" ")) continue;
+    if (line.startsWith("STYLE") || line.startsWith("REGION")) continue;
+    const cleanLine = line.replace(/<[^>]*>/g, "").trim();
+    if (cleanLine) {
+      textLines.push(cleanLine);
+    }
+  }
+  return textLines.join(" ").replace(/\s+/g, " ").trim();
+}
+
+// src/summarization.ts
+var summarySchema = z.object({
+  keywords: z.array(z.string()).max(10),
+  title: z.string().max(100),
+  description: z.string().max(1e3)
+});
+var DEFAULT_PROMPT = "Generate a short title (max 100 characters) and description (max 500 characters) for what happens. Start immediately with the action or subject - never reference that this is a video, content, or storyboard. Example: Title: 'Cooking Pasta Tutorial' Description: 'Someone cooks pasta by boiling water and adding noodles.'";
+var ANTHROPIC_JSON_PROMPT = `You must respond with valid JSON in exactly this format:
+{
+  "title": "Your title here (max 100 characters)",
+  "description": "Your description here (max 500 characters)",
+  "keywords": ["keyword1", "keyword2", "keyword3"]
+}
+
+Do not include any text before or after the JSON. The JSON must be valid and parseable.`;
+async function getSummaryAndTags(assetId, promptOrOptions, options) {
+  let prompt;
+  let actualOptions;
+  if (typeof promptOrOptions === "string") {
+    prompt = promptOrOptions;
+    actualOptions = options || {};
+  } else {
+    prompt = DEFAULT_PROMPT;
+    actualOptions = promptOrOptions || {};
+  }
+  const {
+    provider = "openai",
+    model,
+    tone = "normal",
+    includeTranscript = true,
+    cleanTranscript = true,
+    imageSubmissionMode = "url",
+    imageDownloadOptions,
+    muxTokenId,
+    muxTokenSecret,
+    openaiApiKey,
+    anthropicApiKey,
+    ...config
+  } = actualOptions;
+  const defaultModel = provider === "anthropic" ? "claude-3-5-haiku-20241022" : "gpt-4o-mini";
+  const finalModel = model || defaultModel;
+  const muxId = muxTokenId || process.env.MUX_TOKEN_ID;
+  const muxSecret = muxTokenSecret || process.env.MUX_TOKEN_SECRET;
+  const openaiKey = openaiApiKey || process.env.OPENAI_API_KEY;
+  const anthropicKey = anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+  if (!muxId || !muxSecret) {
+    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
+  }
+  if (provider === "openai" && !openaiKey) {
+    throw new Error("OpenAI API key is required. Provide openaiApiKey in options or set OPENAI_API_KEY environment variable.");
+  }
+  if (provider === "anthropic" && !anthropicKey) {
+    throw new Error("Anthropic API key is required. Provide anthropicApiKey in options or set ANTHROPIC_API_KEY environment variable.");
+  }
+  const mux = new Mux({
+    tokenId: muxId,
+    tokenSecret: muxSecret
+  });
+  let openaiClient;
+  let anthropicClient;
+  if (provider === "openai") {
+    openaiClient = new OpenAI({
+      apiKey: openaiKey
+    });
+  } else if (provider === "anthropic") {
+    anthropicClient = new Anthropic({
+      apiKey: anthropicKey
+    });
+  }
+  let assetData;
+  try {
+    const asset = await mux.video.assets.retrieve(assetId);
+    assetData = asset;
+  } catch (error) {
+    throw new Error(`Failed to fetch asset from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  const playbackId = assetData.playback_ids?.[0]?.id;
+  if (!playbackId) {
+    throw new Error("No playback ID found for this asset");
+  }
+  let transcriptText = "";
+  if (includeTranscript && assetData.tracks) {
+    const textTrack = assetData.tracks.find(
+      (track) => track.type === "text" && track.status === "ready"
+    );
+    if (textTrack) {
+      const transcriptUrl = `https://stream.mux.com/${playbackId}/text/${textTrack.id}.vtt`;
+      try {
+        const transcriptResponse = await fetch(transcriptUrl);
+        if (transcriptResponse.ok) {
+          const rawVttContent = await transcriptResponse.text();
+          transcriptText = cleanTranscript ? extractTextFromVTT(rawVttContent) : rawVttContent;
+        }
+      } catch (error) {
+        console.warn("Failed to fetch transcript:", error);
+      }
+    }
+  }
+  let toneInstruction = "";
+  switch (tone) {
+    case "sassy":
+      toneInstruction = " Answer with a sassy, playful attitude and personality.";
+      break;
+    case "professional":
+      toneInstruction = " Provide a professional, executive-level analysis suitable for business reporting.";
+      break;
+    default:
+      toneInstruction = " Provide a clear, straightforward analysis.";
+  }
+  let contextualPrompt = prompt + toneInstruction;
+  if (transcriptText) {
+    const transcriptType = cleanTranscript ? "transcript" : "WebVTT transcript";
+    contextualPrompt += ` Use the following ${transcriptType} for additional context: "${transcriptText}"`;
+  }
+  const imageUrl = `https://image.mux.com/${playbackId}/storyboard.png?width=640`;
+  let aiAnalysis = null;
+  let retryAttempt = 0;
+  const maxRetries = 3;
+  if (provider === "openai") {
+    if (imageSubmissionMode === "base64") {
+      try {
+        const downloadResult = await downloadImageAsBase64(imageUrl, imageDownloadOptions);
+        const response = await openaiClient.responses.parse({
+          model: finalModel,
+          input: [
+            {
+              role: "system",
+              content: "You are an image analysis tool. You will be given a storyboard image from a video showing multiple frames/scenes, and be expected to return structured data about the contents across all the frames."
+            },
+            {
+              role: "user",
+              content: [
+                {
+                  type: "input_text",
+                  text: contextualPrompt
+                },
+                {
+                  type: "input_image",
+                  image_url: downloadResult.base64Data,
+                  // Use base64 data URI
+                  detail: "high"
+                }
+              ]
+            }
+          ],
+          text: {
+            format: zodTextFormat(summarySchema, "analysis")
+          }
+        });
+        aiAnalysis = response.output_parsed;
+      } catch (error) {
+        throw new Error(`Failed to analyze video content with OpenAI in base64 mode: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    } else {
+      while (retryAttempt <= maxRetries) {
+        try {
+          const response = await openaiClient.responses.parse({
+            model: finalModel,
+            input: [
+              {
+                role: "system",
+                content: "You are an image analysis tool. You will be given a storyboard image from a video showing multiple frames/scenes, and be expected to return structured data about the contents across all the frames."
+              },
+              {
+                role: "user",
+                content: [
+                  {
+                    type: "input_text",
+                    text: contextualPrompt
+                  },
+                  {
+                    type: "input_image",
+                    image_url: imageUrl,
+                    detail: "high"
+                  }
+                ]
+              }
+            ],
+            text: {
+              format: zodTextFormat(summarySchema, "analysis")
+            }
+          });
+          aiAnalysis = response.output_parsed;
+          break;
+        } catch (error) {
+          const isTimeoutError = error instanceof Error && error.message && error.message.includes("Timeout while downloading");
+          if (isTimeoutError && retryAttempt < maxRetries) {
+            await new Promise((resolve) => setTimeout(resolve, 5e3));
+            retryAttempt++;
+            continue;
+          }
+          throw new Error(`Failed to analyze video content with OpenAI: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+      }
+    }
+  } else if (provider === "anthropic") {
+    const anthropicPrompt = `${contextualPrompt}
+
+${ANTHROPIC_JSON_PROMPT}`;
+    if (imageSubmissionMode === "base64") {
+      try {
+        const fileUploadResult = await uploadImageToAnthropicFiles(imageUrl, anthropicKey, imageDownloadOptions);
+        const response = await anthropicClient.messages.create({
+          model: finalModel,
+          max_tokens: 1e3,
+          messages: [
+            {
+              role: "user",
+              content: [
+                {
+                  type: "image",
+                  source: {
+                    type: "file",
+                    file_id: fileUploadResult.fileId
+                  }
+                  // Type assertion for Files API support
+                },
+                {
+                  type: "text",
+                  text: anthropicPrompt
+                }
+              ]
+            }
+          ]
+        }, {
+          headers: {
+            "anthropic-beta": "files-api-2025-04-14"
+          }
+        });
+        const content = response.content[0];
+        if (content.type === "text") {
+          const jsonText = content.text.trim();
+          try {
+            aiAnalysis = JSON.parse(jsonText);
+          } catch (parseError) {
+            throw new Error(`Failed to parse JSON response from Anthropic: ${parseError instanceof Error ? parseError.message : "Unknown error"}`);
+          }
+        } else {
+          throw new Error("Unexpected response type from Anthropic");
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Failed to analyze video content with Anthropic Files API: ${errorMessage}`);
+      }
+    } else {
+      while (retryAttempt <= maxRetries) {
+        try {
+          const response = await anthropicClient.messages.create({
+            model: finalModel,
+            max_tokens: 1e3,
+            messages: [
+              {
+                role: "user",
+                content: [
+                  {
+                    type: "image",
+                    source: {
+                      type: "url",
+                      url: imageUrl
+                    }
+                    // Type assertion to work around SDK type definitions
+                  },
+                  {
+                    type: "text",
+                    text: anthropicPrompt
+                  }
+                ]
+              }
+            ]
+          });
+          const content = response.content[0];
+          if (content.type === "text") {
+            const jsonText = content.text.trim();
+            try {
+              aiAnalysis = JSON.parse(jsonText);
+              break;
+            } catch (parseError) {
+              if (retryAttempt < maxRetries) {
+                console.warn(`Failed to parse JSON from Anthropic (attempt ${retryAttempt + 1}):`, jsonText);
+                retryAttempt++;
+                await new Promise((resolve) => setTimeout(resolve, 2e3));
+                continue;
+              }
+              throw new Error(`Failed to parse JSON response from Anthropic: ${parseError instanceof Error ? parseError.message : "Unknown error"}`);
+            }
+          } else {
+            throw new Error("Unexpected response type from Anthropic");
+          }
+        } catch (error) {
+          if (retryAttempt < maxRetries) {
+            await new Promise((resolve) => setTimeout(resolve, 5e3));
+            retryAttempt++;
+            continue;
+          }
+          throw new Error(`Failed to analyze video content with Anthropic: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+      }
+    }
+  } else {
+    throw new Error(`Unsupported provider: ${provider}`);
+  }
+  if (!aiAnalysis) {
+    throw new Error("No analysis result received from AI provider");
+  }
+  return {
+    assetId,
+    title: aiAnalysis.title || "No title available",
+    description: aiAnalysis.description || "No description available",
+    tags: aiAnalysis.keywords || [],
+    storyboardUrl: imageUrl
+  };
+}
+async function translateCaptions(assetId, fromLanguageCode, toLanguageCode, options = {}) {
+  const {
+    provider = "anthropic",
+    model = "claude-sonnet-4-20250514",
+    muxTokenId,
+    muxTokenSecret,
+    anthropicApiKey,
+    ...config
+  } = options;
+  if (provider !== "anthropic") {
+    throw new Error("Only Anthropic provider is currently supported for translation");
+  }
+  const muxId = muxTokenId || process.env.MUX_TOKEN_ID;
+  const muxSecret = muxTokenSecret || process.env.MUX_TOKEN_SECRET;
+  const anthropicKey = anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+  const s3Endpoint = options.s3Endpoint || process.env.S3_ENDPOINT;
+  const s3Region = options.s3Region || process.env.S3_REGION || "auto";
+  const s3Bucket = options.s3Bucket || process.env.S3_BUCKET;
+  const s3AccessKeyId = options.s3AccessKeyId || process.env.S3_ACCESS_KEY_ID;
+  const s3SecretAccessKey = options.s3SecretAccessKey || process.env.S3_SECRET_ACCESS_KEY;
+  const uploadToMux = options.uploadToMux !== false;
+  if (!muxId || !muxSecret) {
+    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
+  }
+  if (!anthropicKey) {
+    throw new Error("Anthropic API key is required. Provide anthropicApiKey in options or set ANTHROPIC_API_KEY environment variable.");
+  }
+  if (uploadToMux && (!s3Endpoint || !s3Bucket || !s3AccessKeyId || !s3SecretAccessKey)) {
+    throw new Error("S3 configuration is required for uploading to Mux. Provide s3Endpoint, s3Bucket, s3AccessKeyId, and s3SecretAccessKey in options or set S3_ENDPOINT, S3_BUCKET, S3_ACCESS_KEY_ID, and S3_SECRET_ACCESS_KEY environment variables.");
+  }
+  const mux = new Mux({
+    tokenId: muxId,
+    tokenSecret: muxSecret
+  });
+  const anthropicClient = new Anthropic({
+    apiKey: anthropicKey
+  });
+  let assetData;
+  try {
+    const asset = await mux.video.assets.retrieve(assetId);
+    assetData = asset;
+  } catch (error) {
+    throw new Error(`Failed to fetch asset from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  const playbackId = assetData.playback_ids?.[0]?.id;
+  if (!playbackId) {
+    throw new Error("No playback ID found for this asset");
+  }
+  if (!assetData.tracks) {
+    throw new Error("No tracks found for this asset");
+  }
+  const sourceTextTrack = assetData.tracks.find(
+    (track) => track.type === "text" && track.status === "ready" && track.language_code === fromLanguageCode
+  );
+  if (!sourceTextTrack) {
+    throw new Error(`No ready text track found with language code '${fromLanguageCode}' for this asset`);
+  }
+  const vttUrl = `https://stream.mux.com/${playbackId}/text/${sourceTextTrack.id}.vtt`;
+  let vttContent;
+  try {
+    const vttResponse = await fetch(vttUrl);
+    if (!vttResponse.ok) {
+      throw new Error(`Failed to fetch VTT file: ${vttResponse.statusText}`);
+    }
+    vttContent = await vttResponse.text();
+  } catch (error) {
+    throw new Error(`Failed to fetch VTT content: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  console.log(`\u2705 Found VTT content for language '${fromLanguageCode}'`);
+  let translatedVtt;
+  try {
+    const response = await anthropicClient.messages.create({
+      model,
+      max_tokens: 4e3,
+      messages: [
+        {
+          role: "user",
+          content: `Translate the following VTT subtitle file from ${fromLanguageCode} to ${toLanguageCode}. Return the translated VTT in JSON format with the key 'translation'. Preserve all timestamps and VTT formatting exactly as they appear.
+
+${vttContent}`
+        }
+      ]
+    });
+    const content = response.content[0];
+    if (content.type === "text") {
+      const responseText = content.text.trim();
+      try {
+        const cleanedResponse = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
+        const parsed = JSON.parse(cleanedResponse);
+        translatedVtt = parsed.translation;
+      } catch (parseError) {
+        throw new Error(`Failed to parse JSON response from Anthropic: ${parseError instanceof Error ? parseError.message : "Unknown error"}`);
+      }
+    } else {
+      throw new Error("Unexpected response type from Anthropic");
+    }
+  } catch (error) {
+    throw new Error(`Failed to translate VTT with Anthropic: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  console.log(`
+\u2705 Translation completed successfully!`);
+  if (!uploadToMux) {
+    console.log(`\u2705 VTT translated to ${toLanguageCode} successfully!`);
+    return {
+      assetId,
+      sourceLanguageCode: fromLanguageCode,
+      targetLanguageCode: toLanguageCode,
+      originalVtt: vttContent,
+      translatedVtt
+    };
+  }
+  console.log("\u{1F4E4} Uploading translated VTT to S3-compatible storage...");
+  const s3Client = new S3Client({
+    region: s3Region,
+    endpoint: s3Endpoint,
+    credentials: {
+      accessKeyId: s3AccessKeyId,
+      secretAccessKey: s3SecretAccessKey
+    },
+    forcePathStyle: true
+    // Often needed for non-AWS S3 services
+  });
+  const vttKey = `translations/${assetId}/${fromLanguageCode}-to-${toLanguageCode}-${Date.now()}.vtt`;
+  let presignedUrl;
+  try {
+    const upload = new Upload({
+      client: s3Client,
+      params: {
+        Bucket: s3Bucket,
+        Key: vttKey,
+        Body: translatedVtt,
+        ContentType: "text/vtt"
+      }
+    });
+    await upload.done();
+    console.log(`\u2705 VTT uploaded successfully to: ${vttKey}`);
+    const getObjectCommand = new GetObjectCommand({
+      Bucket: s3Bucket,
+      Key: vttKey
+    });
+    presignedUrl = await getSignedUrl(s3Client, getObjectCommand, {
+      expiresIn: 3600
+      // 1 hour
+    });
+    console.log(`\u{1F517} Generated presigned URL (expires in 1 hour)`);
+  } catch (error) {
+    throw new Error(`Failed to upload VTT to S3: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  console.log("\u{1F4F9} Adding translated track to Mux asset...");
+  let uploadedTrackId;
+  try {
+    const languageName = new Intl.DisplayNames(["en"], { type: "language" }).of(toLanguageCode) || toLanguageCode.toUpperCase();
+    const trackName = `${languageName} (auto-translated)`;
+    const trackResponse = await mux.video.assets.createTrack(assetId, {
+      type: "text",
+      text_type: "subtitles",
+      language_code: toLanguageCode,
+      name: trackName,
+      url: presignedUrl
+    });
+    uploadedTrackId = trackResponse.id;
+    console.log(`\u2705 Track added to Mux asset with ID: ${uploadedTrackId}`);
+    console.log(`\u{1F4CB} Track name: "${trackName}"`);
+  } catch (error) {
+    console.warn(`\u26A0\uFE0F Failed to add track to Mux asset: ${error instanceof Error ? error.message : "Unknown error"}`);
+    console.log("\u{1F517} You can manually add the track using this presigned URL:");
+    console.log(presignedUrl);
+  }
+  return {
+    assetId,
+    sourceLanguageCode: fromLanguageCode,
+    targetLanguageCode: toLanguageCode,
+    originalVtt: vttContent,
+    translatedVtt,
+    uploadedTrackId,
+    presignedUrl
+  };
+}
+async function translateAudio(assetId, toLanguageCode, options = {}) {
+  const {
+    provider = "elevenlabs",
+    numSpeakers = 0,
+    // 0 = auto-detect
+    muxTokenId,
+    muxTokenSecret,
+    elevenLabsApiKey,
+    uploadToMux = true,
+    ...config
+  } = options;
+  if (provider !== "elevenlabs") {
+    throw new Error("Only ElevenLabs provider is currently supported for audio translation");
+  }
+  const muxId = muxTokenId || process.env.MUX_TOKEN_ID;
+  const muxSecret = muxTokenSecret || process.env.MUX_TOKEN_SECRET;
+  const elevenLabsKey = elevenLabsApiKey || process.env.ELEVENLABS_API_KEY;
+  const s3Endpoint = options.s3Endpoint || process.env.S3_ENDPOINT;
+  const s3Region = options.s3Region || process.env.S3_REGION || "auto";
+  const s3Bucket = options.s3Bucket || process.env.S3_BUCKET;
+  const s3AccessKeyId = options.s3AccessKeyId || process.env.S3_ACCESS_KEY_ID;
+  const s3SecretAccessKey = options.s3SecretAccessKey || process.env.S3_SECRET_ACCESS_KEY;
+  if (!muxId || !muxSecret) {
+    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
+  }
+  if (!elevenLabsKey) {
+    throw new Error("ElevenLabs API key is required. Provide elevenLabsApiKey in options or set ELEVENLABS_API_KEY environment variable.");
+  }
+  if (uploadToMux && (!s3Endpoint || !s3Bucket || !s3AccessKeyId || !s3SecretAccessKey)) {
+    throw new Error("S3 configuration is required for uploading to Mux. Provide s3Endpoint, s3Bucket, s3AccessKeyId, and s3SecretAccessKey in options or set S3_ENDPOINT, S3_BUCKET, S3_ACCESS_KEY_ID, and S3_SECRET_ACCESS_KEY environment variables.");
+  }
+  const mux = new Mux({
+    tokenId: muxId,
+    tokenSecret: muxSecret
+  });
+  console.log(`\u{1F3AC} Fetching Mux asset: ${assetId}`);
+  let assetData;
+  try {
+    const asset = await mux.video.assets.retrieve(assetId);
+    assetData = asset;
+  } catch (error) {
+    throw new Error(`Failed to fetch asset from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  console.log("\u{1F50D} Checking for audio-only static rendition...");
+  if (!assetData.static_renditions || !assetData.static_renditions.files) {
+    throw new Error("No static renditions found for this asset");
+  }
+  const staticRenditionFiles = assetData.static_renditions.files;
+  if (staticRenditionFiles.length === 0) {
+    throw new Error("No static rendition files found for this asset");
+  }
+  const audioRendition = staticRenditionFiles.find(
+    (rendition) => rendition.name === "audio.m4a" && rendition.status === "ready"
+  );
+  if (!audioRendition) {
+    throw new Error("No ready audio-only static rendition found for this asset. Please ensure the asset has an audio.m4a static rendition.");
+  }
+  const audioUrl = `https://stream.mux.com/${assetData.playback_ids?.[0]?.id}/audio.m4a`;
+  console.log(`\u2705 Found audio rendition: ${audioUrl}`);
+  console.log(`\u{1F399}\uFE0F Creating ElevenLabs dubbing job (auto-detect \u2192 ${toLanguageCode})`);
+  let dubbingId;
+  try {
+    const audioResponse = await fetch(audioUrl);
+    if (!audioResponse.ok) {
+      throw new Error(`Failed to fetch audio file: ${audioResponse.statusText}`);
+    }
+    const audioBuffer = await audioResponse.arrayBuffer();
+    const audioBlob = new Blob([audioBuffer], { type: "audio/mp4" });
+    const audioFile = audioBlob;
+    const formData = new FormData();
+    formData.append("file", audioFile);
+    formData.append("target_lang", toLanguageCode);
+    formData.append("num_speakers", numSpeakers.toString());
+    formData.append("name", `Mux Asset ${assetId} - auto to ${toLanguageCode}`);
+    const dubbingResponse = await fetch("https://api.elevenlabs.io/v1/dubbing", {
+      method: "POST",
+      headers: {
+        "xi-api-key": elevenLabsKey
+      },
+      body: formData
+    });
+    if (!dubbingResponse.ok) {
+      throw new Error(`ElevenLabs API error: ${dubbingResponse.statusText}`);
+    }
+    const dubbingData = await dubbingResponse.json();
+    dubbingId = dubbingData.dubbing_id;
+    console.log(`\u2705 Dubbing job created: ${dubbingId}`);
+    console.log(`\u23F1\uFE0F Expected duration: ${dubbingData.expected_duration_sec}s`);
+  } catch (error) {
+    throw new Error(`Failed to create ElevenLabs dubbing job: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  console.log("\u23F3 Waiting for dubbing to complete...");
+  let dubbingStatus = "dubbing";
+  let pollAttempts = 0;
+  const maxPollAttempts = 180;
+  while (dubbingStatus === "dubbing" && pollAttempts < maxPollAttempts) {
+    await new Promise((resolve) => setTimeout(resolve, 1e4));
+    pollAttempts++;
+    try {
+      const statusResponse = await fetch(`https://api.elevenlabs.io/v1/dubbing/${dubbingId}`, {
+        headers: {
+          "xi-api-key": elevenLabsKey
+        }
+      });
+      if (!statusResponse.ok) {
+        throw new Error(`Status check failed: ${statusResponse.statusText}`);
+      }
+      const statusData = await statusResponse.json();
+      dubbingStatus = statusData.status;
+      console.log(`\u{1F4CA} Status check ${pollAttempts}: ${dubbingStatus}`);
+      if (dubbingStatus === "failed") {
+        throw new Error("ElevenLabs dubbing job failed");
+      }
+    } catch (error) {
+      throw new Error(`Failed to check dubbing status: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  if (dubbingStatus !== "dubbed") {
+    throw new Error(`Dubbing job timed out or failed. Final status: ${dubbingStatus}`);
+  }
+  console.log("\u2705 Dubbing completed successfully!");
+  if (!uploadToMux) {
+    return {
+      assetId,
+      targetLanguageCode: toLanguageCode,
+      dubbingId
+    };
+  }
+  console.log("\u{1F4E5} Downloading dubbed audio from ElevenLabs...");
+  let dubbedAudioBuffer;
+  try {
+    const audioUrl2 = `https://api.elevenlabs.io/v1/dubbing/${dubbingId}/audio/${toLanguageCode}`;
+    const audioResponse = await fetch(audioUrl2, {
+      headers: {
+        "xi-api-key": elevenLabsKey
+      }
+    });
+    if (!audioResponse.ok) {
+      throw new Error(`Failed to fetch dubbed audio: ${audioResponse.statusText}`);
+    }
+    dubbedAudioBuffer = await audioResponse.arrayBuffer();
+    console.log(`\u2705 Downloaded dubbed audio (${dubbedAudioBuffer.byteLength} bytes)`);
+  } catch (error) {
+    throw new Error(`Failed to download dubbed audio: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  console.log("\u{1F4E4} Uploading dubbed audio to S3-compatible storage...");
+  const s3Client = new S3Client({
+    region: s3Region,
+    endpoint: s3Endpoint,
+    credentials: {
+      accessKeyId: s3AccessKeyId,
+      secretAccessKey: s3SecretAccessKey
+    },
+    forcePathStyle: true
+  });
+  const audioKey = `audio-translations/${assetId}/auto-to-${toLanguageCode}-${Date.now()}.m4a`;
+  let presignedUrl;
+  try {
+    const upload = new Upload({
+      client: s3Client,
+      params: {
+        Bucket: s3Bucket,
+        Key: audioKey,
+        Body: new Uint8Array(dubbedAudioBuffer),
+        ContentType: "audio/mp4"
+      }
+    });
+    await upload.done();
+    console.log(`\u2705 Audio uploaded successfully to: ${audioKey}`);
+    const getObjectCommand = new GetObjectCommand({
+      Bucket: s3Bucket,
+      Key: audioKey
+    });
+    presignedUrl = await getSignedUrl(s3Client, getObjectCommand, {
+      expiresIn: 3600
+      // 1 hour
+    });
+    console.log(`\u{1F517} Generated presigned URL (expires in 1 hour)`);
+  } catch (error) {
+    throw new Error(`Failed to upload audio to S3: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  console.log("\u{1F3AC} Adding translated audio track to Mux asset...");
+  let uploadedTrackId;
+  try {
+    const languageName = new Intl.DisplayNames(["en"], { type: "language" }).of(toLanguageCode) || toLanguageCode.toUpperCase();
+    const trackName = `${languageName} (auto-dubbed)`;
+    const trackResponse = await mux.video.assets.createTrack(assetId, {
+      type: "audio",
+      language_code: toLanguageCode,
+      name: trackName,
+      url: presignedUrl
+    });
+    uploadedTrackId = trackResponse.id;
+    console.log(`\u2705 Audio track added to Mux asset with ID: ${uploadedTrackId}`);
+    console.log(`\u{1F3B5} Track name: "${trackName}"`);
+  } catch (error) {
+    console.warn(`\u26A0\uFE0F Failed to add audio track to Mux asset: ${error instanceof Error ? error.message : "Unknown error"}`);
+    console.log("\u{1F517} You can manually add the track using this presigned URL:");
+    console.log(presignedUrl);
+  }
+  return {
+    assetId,
+    targetLanguageCode: toLanguageCode,
+    dubbingId,
+    uploadedTrackId,
+    presignedUrl
+  };
+}
+var chaptersSchema = z.object({
+  chapters: z.array(z.object({
+    startTime: z.number(),
+    title: z.string()
+  }))
+});
+var DEFAULT_SYSTEM_PROMPT = `Your role is to segment the following captions into chunked chapters, summarising each chapter with a title. 
+
+Analyze the transcript and create logical chapter breaks based on topic changes, major transitions, or distinct sections of content. Each chapter should represent a meaningful segment of the video.
+
+You must respond with valid JSON in exactly this format:
+{
+  "chapters": [
+    {"startTime": 0, "title": "Introduction"},
+    {"startTime": 45.5, "title": "Main Topic Discussion"},
+    {"startTime": 120.0, "title": "Conclusion"}
+  ]
+}
+
+Important rules:
+- startTime must be in seconds (not HH:MM:SS format)
+- Always start with startTime: 0 for the first chapter
+- Create 3-8 chapters depending on content length and natural breaks
+- Chapter titles should be concise and descriptive
+- Do not include any text before or after the JSON
+- The JSON must be valid and parseable`;
+var ANTHROPIC_JSON_PROMPT2 = `You must respond with valid JSON in exactly this format:
+{
+  "chapters": [
+    {"startTime": 0, "title": "Chapter title here"},
+    {"startTime": 45.5, "title": "Another chapter title"}
+  ]
+}
+
+Do not include any text before or after the JSON. The JSON must be valid and parseable.`;
+function vttTimestampToSeconds(timestamp) {
+  const parts = timestamp.split(":");
+  if (parts.length !== 3) return 0;
+  const hours = parseInt(parts[0], 10) || 0;
+  const minutes = parseInt(parts[1], 10) || 0;
+  const seconds = parseFloat(parts[2]) || 0;
+  return hours * 3600 + minutes * 60 + seconds;
+}
+function extractTimestampsFromVTT(vttContent) {
+  if (!vttContent.trim()) {
+    return "";
+  }
+  const lines = vttContent.split("\n");
+  const segments = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.includes("-->")) {
+      const startTime = line.split(" --> ")[0].trim();
+      const timeInSeconds = vttTimestampToSeconds(startTime);
+      let j = i + 1;
+      while (j < lines.length && !lines[j].trim()) {
+        j++;
+      }
+      if (j < lines.length) {
+        const text = lines[j].trim().replace(/<[^>]*>/g, "");
+        if (text) {
+          segments.push({ time: timeInSeconds, text });
+        }
+      }
+    }
+  }
+  return segments.map((segment) => `[${Math.floor(segment.time)}s] ${segment.text}`).join("\n");
+}
+async function generateChapters(assetId, languageCode, options = {}) {
+  const {
+    provider = "openai",
+    model,
+    muxTokenId,
+    muxTokenSecret,
+    openaiApiKey,
+    anthropicApiKey,
+    ...config
+  } = options;
+  const defaultModel = provider === "anthropic" ? "claude-3-5-haiku-20241022" : "gpt-4o-mini";
+  const finalModel = model || defaultModel;
+  const muxId = muxTokenId || process.env.MUX_TOKEN_ID;
+  const muxSecret = muxTokenSecret || process.env.MUX_TOKEN_SECRET;
+  const openaiKey = openaiApiKey || process.env.OPENAI_API_KEY;
+  const anthropicKey = anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+  if (!muxId || !muxSecret) {
+    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
+  }
+  if (provider === "openai" && !openaiKey) {
+    throw new Error("OpenAI API key is required for OpenAI provider. Provide openaiApiKey in options or set OPENAI_API_KEY environment variable.");
+  }
+  if (provider === "anthropic" && !anthropicKey) {
+    throw new Error("Anthropic API key is required for Anthropic provider. Provide anthropicApiKey in options or set ANTHROPIC_API_KEY environment variable.");
+  }
+  const mux = new Mux({
+    tokenId: muxId,
+    tokenSecret: muxSecret
+  });
+  let openaiClient;
+  let anthropicClient;
+  if (provider === "openai") {
+    openaiClient = new OpenAI({
+      apiKey: openaiKey
+    });
+  } else if (provider === "anthropic") {
+    anthropicClient = new Anthropic({
+      apiKey: anthropicKey
+    });
+  }
+  let assetData;
+  try {
+    const asset = await mux.video.assets.retrieve(assetId);
+    assetData = asset;
+  } catch (error) {
+    throw new Error(`Failed to fetch asset from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  const playbackId = assetData.playback_ids?.[0]?.id;
+  if (!playbackId) {
+    throw new Error("No playback ID found for this asset");
+  }
+  if (!assetData.tracks) {
+    throw new Error("No tracks found for this asset");
+  }
+  const captionTrack = assetData.tracks.find(
+    (track) => track.type === "text" && track.status === "ready" && track.text_type === "subtitles" && track.language_code === languageCode
+  );
+  if (!captionTrack) {
+    throw new Error(`No caption track found for language '${languageCode}'. Available languages: ${assetData.tracks.filter((t) => t.type === "text").map((t) => t.language_code).join(", ")}`);
+  }
+  const transcriptUrl = `https://stream.mux.com/${playbackId}/text/${captionTrack.id}.vtt`;
+  let vttContent;
+  try {
+    const transcriptResponse = await fetch(transcriptUrl);
+    if (!transcriptResponse.ok) {
+      throw new Error(`Failed to fetch VTT: ${transcriptResponse.statusText}`);
+    }
+    vttContent = await transcriptResponse.text();
+  } catch (error) {
+    throw new Error(`Failed to fetch caption track: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  const timestampedTranscript = extractTimestampsFromVTT(vttContent);
+  if (!timestampedTranscript) {
+    throw new Error("No usable content found in caption track");
+  }
+  let chaptersData = null;
+  if (provider === "openai") {
+    try {
+      const response = await openaiClient.responses.parse({
+        model: finalModel,
+        input: [
+          {
+            role: "system",
+            content: DEFAULT_SYSTEM_PROMPT
+          },
+          {
+            role: "user",
+            content: [
+              {
+                type: "input_text",
+                text: timestampedTranscript
+              }
+            ]
+          }
+        ],
+        text: {
+          format: zodTextFormat(chaptersSchema, "chapters")
+        }
+      });
+      chaptersData = response.output_parsed;
+    } catch (error) {
+      throw new Error(`Failed to generate chapters with OpenAI: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  } else if (provider === "anthropic") {
+    const anthropicPrompt = `${DEFAULT_SYSTEM_PROMPT}
+
+${ANTHROPIC_JSON_PROMPT2}
+
+Transcript:
+${timestampedTranscript}`;
+    try {
+      const response = await anthropicClient.messages.create({
+        model: finalModel,
+        max_tokens: 2e3,
+        messages: [
+          {
+            role: "user",
+            content: anthropicPrompt
+          }
+        ]
+      });
+      const content = response.content[0];
+      if (content.type === "text") {
+        const jsonText = content.text.trim();
+        try {
+          chaptersData = JSON.parse(jsonText);
+        } catch (parseError) {
+          throw new Error(`Failed to parse JSON response from Anthropic: ${parseError instanceof Error ? parseError.message : "Unknown error"}`);
+        }
+      } else {
+        throw new Error("Unexpected response type from Anthropic");
+      }
+    } catch (error) {
+      throw new Error(`Failed to generate chapters with Anthropic: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  } else {
+    throw new Error(`Unsupported provider: ${provider}`);
+  }
+  if (!chaptersData || !chaptersData.chapters) {
+    throw new Error("No chapters generated from AI response");
+  }
+  const validChapters = chaptersData.chapters.filter((chapter) => typeof chapter.startTime === "number" && typeof chapter.title === "string").sort((a, b) => a.startTime - b.startTime);
+  if (validChapters.length === 0) {
+    throw new Error("No valid chapters found in AI response");
+  }
+  if (validChapters[0].startTime !== 0) {
+    validChapters[0].startTime = 0;
+  }
+  return {
+    assetId,
+    languageCode,
+    chapters: validChapters
+  };
+}
+
+// src/utils/storyboard-processor.ts
+init_image_download();
+async function getAssetInfo(assetId, options) {
+  const muxId = options.muxTokenId || process.env.MUX_TOKEN_ID;
+  const muxSecret = options.muxTokenSecret || process.env.MUX_TOKEN_SECRET;
+  if (!muxId || !muxSecret) {
+    throw new Error("Mux credentials are required. Provide muxTokenId and muxTokenSecret in options or set MUX_TOKEN_ID and MUX_TOKEN_SECRET environment variables.");
+  }
+  const mux = new Mux({
+    tokenId: muxId,
+    tokenSecret: muxSecret
+  });
+  try {
+    const asset = await mux.video.assets.retrieve(assetId);
+    const playbackId = asset.playback_ids?.[0]?.id;
+    if (!playbackId) {
+      throw new Error("No playback ID found for this asset");
+    }
+    return {
+      playbackId,
+      duration: asset.duration || void 0
+    };
+  } catch (error) {
+    throw new Error(`Failed to fetch asset from Mux: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function processStoryboardWithAnthropic(imageUrl, prompt, options) {
+  const { apiKey, model, responseParser, imageSubmissionMode = "url", imageDownloadOptions, maxRetries = 3 } = options;
+  const anthropicClient = new Anthropic({ apiKey });
+  let retryAttempt = 0;
+  if (imageSubmissionMode === "base64") {
+    try {
+      const fileUploadResult = await uploadImageToAnthropicFiles(imageUrl, apiKey, imageDownloadOptions);
+      const response = await anthropicClient.messages.create({
+        model,
+        max_tokens: 1e3,
+        messages: [
+          {
+            role: "user",
+            content: [
+              {
+                type: "image",
+                source: {
+                  type: "file",
+                  file_id: fileUploadResult.fileId
+                }
+                // Type assertion for Files API support
+              },
+              {
+                type: "text",
+                text: prompt
+              }
+            ]
+          }
+        ]
+      }, {
+        headers: {
+          "anthropic-beta": "files-api-2025-04-14"
+        }
+      });
+      return responseParser(response);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to process storyboard with Anthropic Files API: ${errorMessage}`);
+    }
+  } else {
+    while (retryAttempt <= maxRetries) {
+      try {
+        const response = await anthropicClient.messages.create({
+          model,
+          max_tokens: 1e3,
+          messages: [
+            {
+              role: "user",
+              content: [
+                {
+                  type: "image",
+                  source: {
+                    type: "url",
+                    url: imageUrl
+                  }
+                  // Type assertion to work around SDK type definitions
+                },
+                {
+                  type: "text",
+                  text: prompt
+                }
+              ]
+            }
+          ]
+        });
+        return responseParser(response);
+      } catch (error) {
+        if (retryAttempt < maxRetries) {
+          await new Promise((resolve) => setTimeout(resolve, 5e3));
+          retryAttempt++;
+          continue;
+        }
+        throw new Error(`Failed to process storyboard with Anthropic: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+  }
+  throw new Error("All retry attempts failed");
+}
+
+// src/burned-in-captions.ts
+var burnedInCaptionsSchema = z.object({
+  hasBurnedInCaptions: z.boolean(),
+  confidence: z.number().min(0).max(1),
+  detectedLanguage: z.string().nullable()
+});
+var ANTHROPIC_SYSTEM_PROMPT = `You are an expert at analyzing video frames to detect burned-in captions (also called open captions or hardcoded subtitles). These are text overlays permanently embedded in video images, common on social media platforms.
+
+Key principles:
+1. Burned-in captions appear across multiple frames throughout the video timeline
+2. End-cards and marketing text appear only in final frames
+3. Captions have consistent positioning and caption-style formatting
+4. Caption text typically changes between frames (dialogue/narration)
+
+Analysis approach:
+- Look for text overlays distributed across different parts of the timeline
+- Distinguish between dialogue captions vs. marketing end-cards
+- Consider text positioning, formatting, and content patterns`;
+var ANTHROPIC_USER_PROMPT = `Analyze this storyboard for burned-in captions:
+
+1. Examine each frame from left to right (timeline order)
+2. Note which frames have text overlays and their positions
+3. Determine the pattern:
+   - Text scattered across timeline = likely captions
+   - Text only in final 1-2 frames = likely end-card/marketing
+
+Classification rules:
+- If text appears in 3+ frames distributed throughout timeline \u2192 burned-in captions
+- If text appears only in final frames \u2192 NOT burned-in captions
+- Look for dialogue-style content vs. marketing taglines
+
+Analyze and classify with confidence level.`;
+var ANTHROPIC_JSON_PROMPT3 = `Apply the frame analysis above.
+
+Key rule: Text appearing only in final 2-3 frames = NOT captions. Text distributed throughout timeline = captions.
+
+Respond ONLY with valid JSON:
+{
+  "hasBurnedInCaptions": true/false,
+  "confidence": 0.85,
+  "detectedLanguage": "English" (or null if no captions or language unclear)
+}
+
+Do not include any text before or after the JSON. The JSON must be valid and parseable.`;
+async function hasBurnedInCaptions(assetId, options = {}) {
+  const {
+    provider = "openai",
+    model,
+    imageSubmissionMode = "url",
+    imageDownloadOptions,
+    muxTokenId,
+    muxTokenSecret,
+    openaiApiKey,
+    anthropicApiKey,
+    ...config
+  } = options;
+  const defaultModel = provider === "anthropic" ? "claude-3-5-haiku-20241022" : "gpt-4o-mini";
+  const finalModel = model || defaultModel;
+  const openaiKey = openaiApiKey || process.env.OPENAI_API_KEY;
+  const anthropicKey = anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+  if (provider === "openai" && !openaiKey) {
+    throw new Error("OpenAI API key is required for OpenAI provider. Provide openaiApiKey in options or set OPENAI_API_KEY environment variable.");
+  }
+  if (provider === "anthropic" && !anthropicKey) {
+    throw new Error("Anthropic API key is required for Anthropic provider. Provide anthropicApiKey in options or set ANTHROPIC_API_KEY environment variable.");
+  }
+  const storyboardOptions = {
+    muxTokenId,
+    muxTokenSecret};
+  const assetInfo = await getAssetInfo(assetId, storyboardOptions);
+  const imageUrl = `https://image.mux.com/${assetInfo.playbackId}/storyboard.png?width=640`;
+  let analysisResult = null;
+  if (provider === "openai") {
+    const OpenAI5 = __require("openai").default;
+    const openaiClient = new OpenAI5({ apiKey: openaiKey });
+    if (imageSubmissionMode === "base64") {
+      const { downloadImageAsBase64: downloadImageAsBase642 } = (init_image_download(), __toCommonJS(image_download_exports));
+      const downloadResult = await downloadImageAsBase642(imageUrl, imageDownloadOptions);
+      const response = await openaiClient.responses.parse({
+        model: finalModel,
+        input: [
+          {
+            role: "system",
+            content: ANTHROPIC_SYSTEM_PROMPT
+          },
+          {
+            role: "user",
+            content: [
+              {
+                type: "input_text",
+                text: ANTHROPIC_USER_PROMPT
+              },
+              {
+                type: "input_image",
+                image_url: downloadResult.base64Data,
+                detail: "high"
+              }
+            ]
+          }
+        ],
+        text: {
+          format: zodTextFormat(burnedInCaptionsSchema, "analysis")
+        }
+      });
+      analysisResult = response.output_parsed;
+    } else {
+      let retryAttempt = 0;
+      const maxRetries = 3;
+      while (retryAttempt <= maxRetries) {
+        try {
+          const response = await openaiClient.responses.parse({
+            model: finalModel,
+            input: [
+              {
+                role: "system",
+                content: ANTHROPIC_SYSTEM_PROMPT
+              },
+              {
+                role: "user",
+                content: [
+                  {
+                    type: "input_text",
+                    text: ANTHROPIC_USER_PROMPT
+                  },
+                  {
+                    type: "input_image",
+                    image_url: imageUrl,
+                    detail: "high"
+                  }
+                ]
+              }
+            ],
+            text: {
+              format: zodTextFormat(burnedInCaptionsSchema, "analysis")
+            }
+          });
+          analysisResult = response.output_parsed;
+          break;
+        } catch (error) {
+          const isTimeoutError = error instanceof Error && error.message && error.message.includes("Timeout while downloading");
+          if (isTimeoutError && retryAttempt < maxRetries) {
+            await new Promise((resolve) => setTimeout(resolve, 5e3));
+            retryAttempt++;
+            continue;
+          }
+          throw new Error(`Failed to analyze storyboard with OpenAI: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+      }
+    }
+  } else if (provider === "anthropic") {
+    const anthropicPrompt = `${ANTHROPIC_USER_PROMPT}
+
+${ANTHROPIC_JSON_PROMPT3}`;
+    const responseParser = (response) => {
+      const content = response.content[0];
+      if (content.type === "text") {
+        const jsonText = content.text.trim();
+        try {
+          return JSON.parse(jsonText);
+        } catch (parseError) {
+          throw new Error(`Failed to parse JSON response from Anthropic: ${parseError instanceof Error ? parseError.message : "Unknown error"}`);
+        }
+      } else {
+        throw new Error("Unexpected response type from Anthropic");
+      }
+    };
+    analysisResult = await processStoryboardWithAnthropic(
+      imageUrl,
+      anthropicPrompt,
+      {
+        apiKey: anthropicKey,
+        model: finalModel,
+        responseParser,
+        imageSubmissionMode,
+        imageDownloadOptions
+      }
+    );
+  } else {
+    throw new Error(`Unsupported provider: ${provider}`);
+  }
+  if (!analysisResult) {
+    throw new Error("No analysis result received from AI provider");
+  }
+  return {
+    assetId,
+    hasBurnedInCaptions: analysisResult.hasBurnedInCaptions ?? false,
+    confidence: analysisResult.confidence ?? 0,
+    detectedLanguage: analysisResult.detectedLanguage ?? null,
+    storyboardUrl: imageUrl
+  };
+}
+
+// src/index.ts
+var version = "0.1.0";
+
+export { generateChapters, getModerationScores, getSummaryAndTags, hasBurnedInCaptions, translateAudio, translateCaptions, version };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map