@elizaos/plugin-video 2.0.0-beta.1 → 2.0.3-beta.6

package/dist/index.js

@@ -1,25 +1,28 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // src/services/video.ts
+import fs from "node:fs";
+import { tmpdir } from "node:os";
+import path2 from "node:path";
 import {
+  elizaLogger as elizaLogger2,
   IVideoService,
   ServiceType,
-  stringToUuid,
-  elizaLogger as elizaLogger2
+  stringToUuid
 } from "@elizaos/core";
 import ffmpeg from "fluent-ffmpeg";
-import fs from "fs";
-import { tmpdir } from "os";
-import path2 from "path";
 
 // src/services/binaries.ts
-import { createHash } from "crypto";
+import { createHash } from "node:crypto";
 import {
   createWriteStream,
   constants as fsConstants,
   promises as fsp
-} from "fs";
-import path from "path";
-import { Readable } from "stream";
-import { pipeline } from "stream/promises";
+} from "node:fs";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 import { elizaLogger, resolveStateDir } from "@elizaos/core";
 import youtubeDl from "youtube-dl-exec";
 function isYtDlpModule(value) {
@@ -30,7 +33,7 @@ if (!isYtDlpModule(youtubeDl)) {
 }
 var ytDlpModule = youtubeDl;
 var YT_DLP_RELEASE_URL = "https://api.github.com/repos/yt-dlp/yt-dlp/releases/latest";
-var YT_DLP_UPDATE_THROTTLE_MS = 60 * 60 * 1e3;
+var YT_DLP_UPDATE_THROTTLE_MS = 60 * 60 * 1000;
 var YT_DLP_META_FILENAME = "yt-dlp.meta.json";
 var EXTRACTOR_BROKEN_PATTERNS = [
   /Unable to extract/i,
@@ -42,16 +45,16 @@ var EXTRACTOR_BROKEN_PATTERNS = [
   /This video is unavailable/i,
   /Got error: HTTP Error 429/i
 ];
-var BinaryResolver = class _BinaryResolver {
+
+class BinaryResolver {
   static _instance = null;
   static instance() {
-    if (!_BinaryResolver._instance)
-      _BinaryResolver._instance = new _BinaryResolver();
-    return _BinaryResolver._instance;
+    if (!BinaryResolver._instance)
+      BinaryResolver._instance = new BinaryResolver;
+    return BinaryResolver._instance;
   }
-  /** Test hook: drop the singleton so the next instance() returns fresh state. */
   static resetForTests() {
-    _BinaryResolver._instance = null;
+    BinaryResolver._instance = null;
   }
   binariesDir;
   releaseUrl;
@@ -64,7 +67,7 @@ var BinaryResolver = class _BinaryResolver {
   resolvedYtDlpPath = null;
   resolvedYtDlpSource = null;
   cachedRunner = null;
-  resolvedFfmpegPath = void 0;
+  resolvedFfmpegPath = undefined;
   updateInFlight = null;
   constructor(opts = {}) {
     this.binariesDir = opts.binariesDir ?? defaultBinariesDir();
@@ -74,7 +77,7 @@ var BinaryResolver = class _BinaryResolver {
     this.disableAutoUpdate = opts.disableAutoUpdate ?? envBool("ELIZA_DISABLE_YTDLP_AUTOUPDATE");
     this.preferSystemPath = opts.preferSystemPath ?? envBool("ELIZA_YT_DLP_PREFER_PATH");
     this.updateThrottleMs = opts.updateThrottleMs ?? YT_DLP_UPDATE_THROTTLE_MS;
-    this.envOverridePath = opts.envOverridePath !== void 0 ? opts.envOverridePath : process.env.ELIZA_YT_DLP_PATH ?? null;
+    this.envOverridePath = opts.envOverridePath !== undefined ? opts.envOverridePath : process.env.ELIZA_YT_DLP_PATH ?? null;
   }
   get cacheDir() {
     return this.binariesDir;
@@ -85,26 +88,17 @@ var BinaryResolver = class _BinaryResolver {
   get metaPath() {
     return path.join(this.binariesDir, YT_DLP_META_FILENAME);
   }
-  /**
-   * Resolve the yt-dlp binary path. Order:
-   *   1. ELIZA_YT_DLP_PATH env override.
-   *   2. If ELIZA_YT_DLP_PREFER_PATH=1: system PATH, then cache.
-   *   3. Otherwise: cache (download if missing) → PATH fallback.
-   */
   async getYtDlpPath() {
-    if (this.resolvedYtDlpPath) return this.resolvedYtDlpPath;
+    if (this.resolvedYtDlpPath)
+      return this.resolvedYtDlpPath;
     if (this.envOverridePath) {
       if (await isExecutable(this.envOverridePath)) {
         this.resolvedYtDlpPath = this.envOverridePath;
         this.resolvedYtDlpSource = "env";
-        elizaLogger.log(
-          `[plugin-video] Using yt-dlp from env override: ${this.envOverridePath}`
-        );
+        elizaLogger.log(`[plugin-video] Using yt-dlp from env override: ${this.envOverridePath}`);
         return this.envOverridePath;
       }
-      elizaLogger.warn(
-        `[plugin-video] ELIZA_YT_DLP_PATH=${this.envOverridePath} is not executable; falling through.`
-      );
+      elizaLogger.warn(`[plugin-video] ELIZA_YT_DLP_PATH=${this.envOverridePath} is not executable; falling through.`);
     }
     if (this.preferSystemPath) {
       const sys2 = await lookupOnPath("yt-dlp");
@@ -119,40 +113,32 @@ var BinaryResolver = class _BinaryResolver {
     if (await isExecutable(cachePath)) {
       this.resolvedYtDlpPath = cachePath;
       this.resolvedYtDlpSource = "cache";
-      elizaLogger.log(
-        `[plugin-video] Using yt-dlp from managed cache: ${cachePath}`
-      );
+      elizaLogger.log(`[plugin-video] Using yt-dlp from managed cache: ${cachePath}`);
       return cachePath;
     }
     const sys = await lookupOnPath("yt-dlp");
     if (sys) {
       this.resolvedYtDlpPath = sys;
       this.resolvedYtDlpSource = "path";
-      elizaLogger.log(
-        `[plugin-video] Using yt-dlp from PATH (cache empty): ${sys}`
-      );
+      elizaLogger.log(`[plugin-video] Using yt-dlp from PATH (cache empty): ${sys}`);
       return sys;
     }
     const bundled = await getBundledYtDlpPath();
     if (bundled) {
       this.resolvedYtDlpPath = bundled;
       this.resolvedYtDlpSource = "bundled";
-      elizaLogger.log(
-        `[plugin-video] Using yt-dlp from youtube-dl-exec bundle: ${bundled}`
-      );
+      elizaLogger.log(`[plugin-video] Using yt-dlp from youtube-dl-exec bundle: ${bundled}`);
       return bundled;
     }
-    elizaLogger.log(
-      "[plugin-video] No yt-dlp binary found; downloading to managed cache."
-    );
+    elizaLogger.log("[plugin-video] No yt-dlp binary found; downloading to managed cache.");
     await this.downloadYtDlp();
     this.resolvedYtDlpPath = cachePath;
     this.resolvedYtDlpSource = "cache";
     return cachePath;
   }
-  /** Resolution order: ELIZA_FFMPEG_PATH env → system ffmpeg → ffmpeg-static. */
   async getFfmpegPath() {
-    if (this.resolvedFfmpegPath !== void 0) return this.resolvedFfmpegPath;
+    if (this.resolvedFfmpegPath !== undefined)
+      return this.resolvedFfmpegPath;
     const envPath = process.env.ELIZA_FFMPEG_PATH;
     if (envPath && await isExecutable(envPath)) {
       this.resolvedFfmpegPath = envPath;
@@ -165,33 +151,24 @@ var BinaryResolver = class _BinaryResolver {
     }
     try {
       const mod = await import("ffmpeg-static");
-      const staticPath = typeof mod === "string" ? mod : mod && typeof mod === "object" && "default" in mod ? mod.default : null;
+      const staticPath = typeof mod === "string" ? mod : mod && typeof mod === "object" && ("default" in mod) ? mod.default : null;
       if (typeof staticPath === "string" && staticPath.length > 0 && await isExecutable(staticPath)) {
         this.resolvedFfmpegPath = staticPath;
         return staticPath;
       }
     } catch (err) {
-      elizaLogger.warn(
-        `[plugin-video] ffmpeg-static not loadable: ${describeError(err)}`
-      );
+      elizaLogger.warn(`[plugin-video] ffmpeg-static not loadable: ${describeError(err)}`);
     }
     this.resolvedFfmpegPath = null;
     return null;
   }
-  /**
-   * Build (or reuse) the yt-dlp runner bound to the resolved binary path.
-   * The runner mirrors `youtube-dl-exec`'s default callable signature.
-   */
   async getYtDlpRunner() {
-    if (this.cachedRunner) return this.cachedRunner;
+    if (this.cachedRunner)
+      return this.cachedRunner;
     const binPath = await this.getYtDlpPath();
     this.cachedRunner = ytDlpModule.create(binPath);
     return this.cachedRunner;
   }
-  /**
-   * Run yt-dlp with one auto-update + retry attempt on extractor-failure
-   * patterns, when the active binary is the managed cache.
-   */
   async runYtDlp(url, flags) {
     const runner = await this.getYtDlpRunner();
     try {
@@ -209,17 +186,14 @@ var BinaryResolver = class _BinaryResolver {
     }
   }
   shouldRetryWithUpdate(err) {
-    if (this.disableAutoUpdate) return false;
+    if (this.disableAutoUpdate)
+      return false;
     if (this.resolvedYtDlpSource !== "cache" && this.resolvedYtDlpSource !== "bundled") {
       return false;
     }
     const msg = errorMessage(err);
     return EXTRACTOR_BROKEN_PATTERNS.some((p) => p.test(msg));
   }
-  /**
-   * Run a yt-dlp update attempt, throttled to once per `updateThrottleMs`.
-   * Returns true iff a fresh binary was successfully installed.
-   */
   async tryUpdate() {
     if (this.updateInFlight) {
       await this.updateInFlight;
@@ -229,9 +203,7 @@ var BinaryResolver = class _BinaryResolver {
     if (meta) {
       const sinceLast = this.now() - meta.lastUpdateAttemptedAt;
       if (sinceLast < this.updateThrottleMs) {
-        elizaLogger.warn(
-          `[plugin-video] yt-dlp update throttled (last attempt ${Math.floor(sinceLast / 1e3)}s ago).`
-        );
+        elizaLogger.warn(`[plugin-video] yt-dlp update throttled (last attempt ${Math.floor(sinceLast / 1000)}s ago).`);
         return false;
       }
     }
@@ -245,9 +217,7 @@ var BinaryResolver = class _BinaryResolver {
       await job;
       return true;
     } catch (err) {
-      elizaLogger.error(
-        `[plugin-video] yt-dlp update failed: ${describeError(err)}`
-      );
+      elizaLogger.error(`[plugin-video] yt-dlp update failed: ${describeError(err)}`);
       return false;
     } finally {
       this.updateInFlight = null;
@@ -258,7 +228,6 @@ var BinaryResolver = class _BinaryResolver {
     this.resolvedYtDlpPath = null;
     this.resolvedYtDlpSource = null;
   }
-  /** Force a fresh yt-dlp download regardless of throttle. Test/admin hook. */
   async forceUpdateYtDlp() {
     const meta = await this.downloadYtDlp();
     this.resetRunnerCache();
@@ -287,39 +256,25 @@ var BinaryResolver = class _BinaryResolver {
     };
     await this.writeMeta(next);
   }
-  /**
-   * Download the latest yt-dlp release for this platform, verify the SHA256
-   * against the published `SHA2-256SUMS`, and atomically replace the cached
-   * binary. Returns the new metadata on success; throws on any failure.
-   */
   async downloadYtDlp() {
     const release = await this.fetchRelease();
     const assetName = ytDlpAssetName();
     const asset = release.assets.find((a) => a.name === assetName);
     if (!asset) {
-      throw new Error(
-        `yt-dlp release ${release.tag_name} has no asset named '${assetName}'`
-      );
+      throw new Error(`yt-dlp release ${release.tag_name} has no asset named '${assetName}'`);
     }
     const sumsAsset = release.assets.find((a) => a.name === "SHA2-256SUMS");
     if (!sumsAsset) {
-      throw new Error(
-        `yt-dlp release ${release.tag_name} has no SHA2-256SUMS asset`
-      );
-    }
-    const expectedSha = await this.fetchExpectedSha(
-      sumsAsset.browser_download_url,
-      assetName
-    );
+      throw new Error(`yt-dlp release ${release.tag_name} has no SHA2-256SUMS asset`);
+    }
+    const expectedSha = await this.fetchExpectedSha(sumsAsset.browser_download_url, assetName);
     await fsp.mkdir(this.binariesDir, { recursive: true });
     const tmpPath = `${this.cachedYtDlpPath}.tmp.${process.pid}.${Date.now()}`;
     await this.downloadToFile(asset.browser_download_url, tmpPath);
     const actualSha = await sha256OfFile(tmpPath);
     if (actualSha !== expectedSha) {
       await safeUnlink(tmpPath);
-      throw new Error(
-        `yt-dlp SHA256 mismatch: expected ${expectedSha}, got ${actualSha}`
-      );
+      throw new Error(`yt-dlp SHA256 mismatch: expected ${expectedSha}, got ${actualSha}`);
     }
     await fsp.chmod(tmpPath, 493);
     await fsp.rename(tmpPath, this.cachedYtDlpPath);
@@ -331,9 +286,7 @@ var BinaryResolver = class _BinaryResolver {
       lastUpdateAttemptedAt: this.now()
     };
     await this.writeMeta(meta);
-    elizaLogger.log(
-      `[plugin-video] yt-dlp ${release.tag_name} installed at ${this.cachedYtDlpPath}`
-    );
+    elizaLogger.log(`[plugin-video] yt-dlp ${release.tag_name} installed at ${this.cachedYtDlpPath}`);
     return meta;
   }
   async fetchRelease() {
@@ -341,23 +294,20 @@ var BinaryResolver = class _BinaryResolver {
       headers: { Accept: "application/vnd.github+json" }
     });
     if (!res.ok) {
-      throw new Error(
-        `yt-dlp release fetch failed: ${res.status} ${res.statusText}`
-      );
+      throw new Error(`yt-dlp release fetch failed: ${res.status} ${res.statusText}`);
     }
     return await res.json();
   }
   async fetchExpectedSha(sumsUrl, assetName) {
     const res = await this.fetchImpl(sumsUrl);
     if (!res.ok) {
-      throw new Error(
-        `SHA2-256SUMS fetch failed: ${res.status} ${res.statusText}`
-      );
+      throw new Error(`SHA2-256SUMS fetch failed: ${res.status} ${res.statusText}`);
     }
     const text = await res.text();
     for (const line of text.split(/\r?\n/)) {
       const trimmed = line.trim();
-      if (!trimmed) continue;
+      if (!trimmed)
+        continue;
       const parts = trimmed.split(/\s+/);
       if (parts.length >= 2 && parts[parts.length - 1] === assetName) {
         return parts[0].toLowerCase();
@@ -368,30 +318,30 @@ var BinaryResolver = class _BinaryResolver {
   async downloadToFile(url, dest) {
     const res = await this.fetchImpl(url);
     if (!res.ok || !res.body) {
-      throw new Error(
-        `yt-dlp binary fetch failed: ${res.status} ${res.statusText}`
-      );
+      throw new Error(`yt-dlp binary fetch failed: ${res.status} ${res.statusText}`);
     }
-    const nodeStream = Readable.fromWeb(
-      res.body
-    );
+    const nodeStream = Readable.fromWeb(res.body);
     await pipeline(nodeStream, createWriteStream(dest));
   }
-};
+}
 function defaultBinariesDir() {
   const explicit = process.env.ELIZA_BINARIES_DIR;
-  if (explicit) return explicit;
+  if (explicit)
+    return explicit;
   return path.join(resolveStateDir(), "binaries");
 }
 function ytDlpAssetName() {
   const platform = process.platform;
   const arch = process.arch;
-  if (platform === "darwin") return "yt-dlp_macos";
+  if (platform === "darwin")
+    return "yt-dlp_macos";
   if (platform === "win32")
     return arch === "ia32" ? "yt-dlp_x86.exe" : "yt-dlp.exe";
   if (platform === "linux") {
-    if (arch === "arm64") return "yt-dlp_linux_aarch64";
-    if (arch === "arm") return "yt-dlp_linux_armv7l";
+    if (arch === "arm64")
+      return "yt-dlp_linux_aarch64";
+    if (arch === "arm")
+      return "yt-dlp_linux_armv7l";
     return "yt-dlp_linux";
   }
   throw new Error(`Unsupported platform for yt-dlp: ${platform}/${arch}`);
@@ -409,31 +359,31 @@ async function isExecutable(p) {
   }
 }
 async function getBundledYtDlpPath() {
-  var _a;
   try {
     const constantsModule = await import("youtube-dl-exec/src/constants.js");
-    const fromConstants = ((_a = constantsModule.default) == null ? void 0 : _a.YOUTUBE_DL_PATH) ?? constantsModule.YOUTUBE_DL_PATH;
+    const fromConstants = constantsModule.default?.YOUTUBE_DL_PATH ?? constantsModule.YOUTUBE_DL_PATH;
     if (typeof fromConstants === "string" && fromConstants.length > 0 && await isExecutable(fromConstants)) {
       return fromConstants;
     }
-  } catch {
-  }
+  } catch {}
   try {
-    const { createRequire } = await import("module");
-    const req = createRequire(import.meta.url);
+    const { createRequire: createRequire2 } = await import("node:module");
+    const req = createRequire2(import.meta.url);
     const pkgPath = req.resolve("youtube-dl-exec/package.json");
     const candidate = path.join(path.dirname(pkgPath), "bin", ytDlpFileName());
-    if (await isExecutable(candidate)) return candidate;
-  } catch {
-  }
+    if (await isExecutable(candidate))
+      return candidate;
+  } catch {}
   return null;
 }
 async function lookupOnPath(name) {
   const pathEnv = process.env.PATH;
-  if (!pathEnv) return null;
+  if (!pathEnv)
+    return null;
   const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").map((e) => e.toLowerCase()) : [""];
   for (const dir of pathEnv.split(path.delimiter)) {
-    if (!dir) continue;
+    if (!dir)
+      continue;
     for (const ext of exts) {
       const candidate = path.join(dir, `${name}${ext}`);
       if (await isExecutable(candidate)) {
@@ -448,7 +398,8 @@ async function sha256OfFile(p) {
   const fd = await fsp.open(p, "r");
   try {
     const stream = fd.createReadStream();
-    for await (const chunk of stream) hash.update(chunk);
+    for await (const chunk of stream)
+      hash.update(chunk);
   } finally {
     await fd.close();
   }
@@ -457,21 +408,24 @@ async function sha256OfFile(p) {
 async function safeUnlink(p) {
   try {
     await fsp.unlink(p);
-  } catch {
-  }
+  } catch {}
 }
 function envBool(name) {
   const v = process.env[name];
-  if (!v) return false;
+  if (!v)
+    return false;
   return v === "1" || v.toLowerCase() === "true";
 }
 function errorMessage(err) {
-  if (!err) return "";
-  if (typeof err === "string") return err;
+  if (!err)
+    return "";
+  if (typeof err === "string")
+    return err;
   const anyErr = err;
   if (typeof anyErr.stderr === "string" && anyErr.stderr.length > 0)
     return anyErr.stderr;
-  if (typeof anyErr.message === "string") return anyErr.message;
+  if (typeof anyErr.message === "string")
+    return anyErr.message;
   try {
     return JSON.stringify(err);
   } catch {
@@ -483,14 +437,28 @@ function describeError(err) {
 }
 
 // src/services/video.ts
-var VideoService = class _VideoService extends IVideoService {
+function loggableError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function parseYtDlpUploadDate(value) {
+  if (!value)
+    return;
+  const compact = value.match(/^(\d{4})(\d{2})(\d{2})$/);
+  if (compact) {
+    const [, year, month, day] = compact;
+    return new Date(`${year}-${month}-${day}T00:00:00.000Z`);
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+
+class VideoService extends IVideoService {
   capabilityDescription = "Video download, processing, and conversion capabilities";
   static serviceType = ServiceType.VIDEO;
   cacheKey = "content/video";
   dataDir = "./content_cache";
   binaries;
   ffmpegPathConfigured = false;
-  /** Serialize downloads/processing so cache keys and temp files do not race. */
   processingChain = Promise.resolve();
   constructor(runtime, binaries) {
     super(runtime);
@@ -498,7 +466,7 @@ var VideoService = class _VideoService extends IVideoService {
     this.ensureDataDirectoryExists();
   }
   static async start(runtime) {
-    const service = new _VideoService(runtime);
+    const service = new VideoService(runtime);
     await service.initialize(runtime);
     return service;
   }
@@ -506,38 +474,34 @@ var VideoService = class _VideoService extends IVideoService {
     await this.configureFfmpeg();
   }
   async configureFfmpeg() {
-    if (this.ffmpegPathConfigured) return;
+    if (this.ffmpegPathConfigured)
+      return;
     const ffmpegPath = await this.binaries.getFfmpegPath();
     if (ffmpegPath) {
       ffmpeg.setFfmpegPath(ffmpegPath);
       elizaLogger2.log(`[plugin-video] ffmpeg path: ${ffmpegPath}`);
     } else {
-      elizaLogger2.warn(
-        "[plugin-video] No ffmpeg binary located via env, PATH, or ffmpeg-static; fluent-ffmpeg will fail at first invocation."
-      );
+      elizaLogger2.warn("[plugin-video] No ffmpeg binary located via env, PATH, or ffmpeg-static; fluent-ffmpeg will fail at first invocation.");
     }
     this.ffmpegPathConfigured = true;
   }
   async stop() {
     this.processingChain = Promise.resolve();
   }
-  // Required abstract methods from IVideoService
   async getVideoInfo(url) {
     const videoInfo = await this.fetchVideoInfo(url);
-    const formats = (videoInfo.formats ?? []).map(
-      (f) => ({
-        formatId: f.format_id ?? "",
-        url: f.url ?? "",
-        extension: f.ext ?? "",
-        quality: f.quality !== void 0 && f.quality !== "" ? String(f.quality) : "unknown",
-        fileSize: f.filesize,
-        videoCodec: f.vcodec,
-        audioCodec: f.acodec,
-        resolution: f.resolution,
-        fps: f.fps,
-        bitrate: f.tbr
-      })
-    );
+    const formats = (videoInfo.formats ?? []).map((f) => ({
+      formatId: f.format_id ?? "",
+      url: f.url ?? "",
+      extension: f.ext ?? "",
+      quality: f.quality !== undefined && f.quality !== "" ? String(f.quality) : "unknown",
+      fileSize: f.filesize,
+      videoCodec: f.vcodec,
+      audioCodec: f.acodec,
+      resolution: f.resolution,
+      fps: f.fps,
+      bitrate: f.tbr
+    }));
     return {
       title: videoInfo.title,
       duration: videoInfo.duration,
@@ -546,13 +510,13 @@ var VideoService = class _VideoService extends IVideoService {
       description: videoInfo.description,
       uploader: videoInfo.channel,
       viewCount: videoInfo.view_count,
-      uploadDate: videoInfo.upload_date ? new Date(videoInfo.upload_date) : void 0,
+      uploadDate: parseYtDlpUploadDate(videoInfo.upload_date),
       formats
     };
   }
   async downloadVideo(url, options) {
     const videoId = this.getVideoId(url);
-    const outputFile = (options == null ? void 0 : options.outputPath) || path2.join(this.dataDir, `${videoId}.mp4`);
+    const outputFile = options?.outputPath || path2.join(this.dataDir, `${videoId}.mp4`);
     if (fs.existsSync(outputFile)) {
       return outputFile;
     }
@@ -562,23 +526,23 @@ var VideoService = class _VideoService extends IVideoService {
         output: outputFile,
         writeInfoJson: true
       };
-      if (options == null ? void 0 : options.format) {
+      if (options?.format) {
         downloadOptions.format = options.format;
       }
-      if (options == null ? void 0 : options.quality) {
+      if (options?.quality) {
         downloadOptions.format = options.quality;
       }
-      if (options == null ? void 0 : options.audioOnly) {
+      if (options?.audioOnly) {
         downloadOptions.extractAudio = true;
         downloadOptions.audioFormat = "mp3";
       }
-      if (options == null ? void 0 : options.videoOnly) {
+      if (options?.videoOnly) {
         downloadOptions.format = "bestvideo[ext=mp4]/best[ext=mp4]/best";
       }
       await this.binaries.runYtDlp(url, downloadOptions);
       return outputFile;
     } catch (error) {
-      elizaLogger2.log("Error downloading video:", error);
+      elizaLogger2.log("Error downloading video:", loggableError(error));
       throw new Error("Failed to download video");
     }
   }
@@ -594,7 +558,7 @@ var VideoService = class _VideoService extends IVideoService {
         elizaLogger2.log("Audio extraction complete");
         resolve(audioFile);
       }).on("error", (err) => {
-        elizaLogger2.log("Error extracting audio:", err);
+        elizaLogger2.log("Error extracting audio:", loggableError(err));
         reject(err);
       }).run();
     });
@@ -616,7 +580,7 @@ var VideoService = class _VideoService extends IVideoService {
         elizaLogger2.log("Thumbnail generation complete");
         resolve(thumbnailFile);
       }).on("error", (err) => {
-        elizaLogger2.log("Error generating thumbnail:", err);
+        elizaLogger2.log("Error generating thumbnail:", loggableError(err));
         reject(err);
       });
     });
@@ -625,42 +589,41 @@ var VideoService = class _VideoService extends IVideoService {
     await this.configureFfmpeg();
     return new Promise((resolve, reject) => {
       let command = ffmpeg(videoPath);
-      if (options == null ? void 0 : options.startTime) {
+      if (options?.startTime) {
         command = command.seekInput(options.startTime);
       }
       command = command.output(outputPath);
-      if (options == null ? void 0 : options.endTime) {
+      if (options?.endTime) {
         command = command.duration(options.endTime - (options.startTime || 0));
       }
-      if (options == null ? void 0 : options.outputFormat) {
+      if (options?.outputFormat) {
         command = command.format(options.outputFormat);
       }
-      if (options == null ? void 0 : options.resolution) {
+      if (options?.resolution) {
         command = command.size(options.resolution);
       }
-      if (options == null ? void 0 : options.bitrate) {
+      if (options?.bitrate) {
         command = command.videoBitrate(options.bitrate);
       }
-      if (options == null ? void 0 : options.framerate) {
+      if (options?.framerate) {
         command = command.fps(options.framerate);
       }
-      if (options == null ? void 0 : options.videoCodec) {
+      if (options?.videoCodec) {
         command = command.videoCodec(options.videoCodec);
       }
-      if (options == null ? void 0 : options.audioCodec) {
+      if (options?.audioCodec) {
         command = command.audioCodec(options.audioCodec);
       }
       command.on("end", () => {
         elizaLogger2.log("Video conversion complete");
         resolve(outputPath);
       }).on("error", (err) => {
-        elizaLogger2.log("Error converting video:", err);
+        elizaLogger2.log("Error converting video:", loggableError(err));
         reject(err);
       }).run();
     });
   }
   async getAvailableFormats(url) {
-    var _a;
     try {
       const result = await this.binaries.runYtDlp(url, {
         dumpJson: true,
@@ -673,12 +636,12 @@ var VideoService = class _VideoService extends IVideoService {
       });
       if (typeof result === "object" && result !== null && "formats" in result) {
         const parsed = result;
-        if ((_a = parsed.formats) == null ? void 0 : _a.length) {
+        if (parsed.formats?.length) {
           return parsed.formats.map((format) => ({
             formatId: format.format_id ?? "",
-            url: format.url,
-            extension: format.ext,
-            quality: format.quality !== void 0 && format.quality !== "" ? String(format.quality) : "unknown",
+            url: format.url ?? "",
+            extension: format.ext ?? "",
+            quality: format.quality !== undefined && format.quality !== "" ? String(format.quality) : "unknown",
             fileSize: format.filesize,
             videoCodec: format.vcodec,
             audioCodec: format.acodec,
@@ -690,7 +653,7 @@ var VideoService = class _VideoService extends IVideoService {
       }
       return [];
     } catch (error) {
-      elizaLogger2.log("Error getting available formats:", error);
+      elizaLogger2.log("Error getting available formats:", loggableError(error));
       throw new Error("Failed to get available formats");
     }
   }
@@ -722,27 +685,22 @@ var VideoService = class _VideoService extends IVideoService {
       });
       return outputFile;
     } catch (error) {
-      elizaLogger2.log("Error downloading media:", error);
+      elizaLogger2.log("Error downloading media:", loggableError(error));
       throw new Error("Failed to download media");
     }
   }
   async processVideo(url, runtime) {
-    const run = this.processingChain.then(
-      () => this.processVideoFromUrl(url, runtime)
-    );
-    this.processingChain = run.then(
-      () => void 0,
-      () => void 0
-    );
+    const run = this.processingChain.then(() => this.processVideoFromUrl(url, runtime));
+    this.processingChain = run.then(() => {
+      return;
+    }, () => {
+      return;
+    });
     return run;
   }
   async processVideoFromUrl(url, runtime) {
-    var _a;
-    const videoId = ((_a = url.match(
-      /(?:youtu\.be\/|youtube\.com(?:\/embed\/|\/v\/|\/watch\?v=|\/watch\?.+&v=))([^\/&?]+)/
-      // eslint-disable-line
-    )) == null ? void 0 : _a[1]) || "";
-    const videoUuid = this.getVideoId(videoId);
+    const extractedVideoId = url.match(/(?:youtu\.be\/|youtube\.com(?:\/embed\/|\/v\/|\/watch\?v=|\/watch\?.+&v=))([^/&?]+)/)?.[1] || url;
+    const videoUuid = this.getVideoId(extractedVideoId);
     const cacheKey = `${this.cacheKey}/${videoUuid}`;
     const cached = await runtime.getCache(cacheKey);
     if (cached) {
@@ -780,7 +738,7 @@ var VideoService = class _VideoService extends IVideoService {
           };
         }
       } catch (error) {
-        elizaLogger2.log("Error downloading MP4 file:", error);
+        elizaLogger2.log("Error downloading MP4 file:", loggableError(error));
       }
     }
     try {
@@ -798,36 +756,32 @@ var VideoService = class _VideoService extends IVideoService {
       });
       return result;
     } catch (error) {
-      elizaLogger2.log("Error fetching video info:", error);
+      elizaLogger2.log("Error fetching video info:", loggableError(error));
       throw new Error("Failed to fetch video information");
     }
   }
   async getTranscript(url, videoInfo, runtime) {
     elizaLogger2.log("Getting transcript");
     try {
-      if (videoInfo.subtitles && videoInfo.subtitles.en) {
+      if (videoInfo.subtitles?.en) {
         elizaLogger2.log("Manual subtitles found");
-        const srtContent = await this.downloadSRT(
-          videoInfo.subtitles.en[0].url
-        );
+        const srtContent = await this.downloadSRT(videoInfo.subtitles.en[0].url);
         return this.parseSRT(srtContent);
       }
-      if (videoInfo.automatic_captions && videoInfo.automatic_captions.en) {
+      if (videoInfo.automatic_captions?.en) {
         elizaLogger2.log("Automatic captions found");
         const captionUrl = videoInfo.automatic_captions.en[0].url;
         const captionContent = await this.downloadCaption(captionUrl);
         return this.parseCaption(captionContent);
       }
-      if (videoInfo.categories && videoInfo.categories.includes("Music")) {
+      if (videoInfo.categories?.includes("Music")) {
         elizaLogger2.log("Music video detected, no lyrics available");
         return "No lyrics available.";
       }
-      elizaLogger2.log(
-        "No subtitles or captions found, falling back to audio transcription"
-      );
+      elizaLogger2.log("No subtitles or captions found, falling back to audio transcription");
       return this.transcribeAudio(url, runtime);
     } catch (error) {
-      elizaLogger2.log("Error in getTranscript:", error);
+      elizaLogger2.log("Error in getTranscript:", loggableError(error));
       throw error;
     }
   }
@@ -843,19 +797,23 @@ var VideoService = class _VideoService extends IVideoService {
     elizaLogger2.log("Parsing caption");
     try {
       const jsonContent = JSON.parse(captionContent);
-      if (jsonContent.events) {
-        return jsonContent.events.filter((event) => event.segs).map((event) => event.segs.map((seg) => seg.utf8).join("")).join("").replace("\n", " ");
+      if (Array.isArray(jsonContent.events)) {
+        return jsonContent.events.filter((event) => Array.isArray(event.segs)).map((event) => event.segs.map((seg) => seg.utf8 ?? "").join("")).join("").replace(`
+`, " ");
       } else {
-        elizaLogger2.log("Unexpected caption format:", jsonContent);
+        elizaLogger2.log("Unexpected caption format:", JSON.stringify(jsonContent));
         return "Error: Unable to parse captions";
       }
     } catch (error) {
-      elizaLogger2.log("Error parsing caption:", error);
+      elizaLogger2.log("Error parsing caption:", loggableError(error));
       return "Error: Unable to parse captions";
     }
   }
   parseSRT(srtContent) {
-    return srtContent.split("\n\n").map((block) => block.split("\n").slice(2).join(" ")).join(" ");
+    return srtContent.split(`
+
+`).map((block) => block.split(`
+`).slice(2).join(" ")).join(" ");
   }
   async downloadSRT(url) {
     elizaLogger2.log("downloadSRT");
@@ -880,18 +838,14 @@ var VideoService = class _VideoService extends IVideoService {
     elizaLogger2.log(`Audio file size: ${audioBuffer.length} bytes`);
     elizaLogger2.log("Starting transcription...");
     const startTime = Date.now();
-    const transcriptionService = runtime.getService(
-      ServiceType.TRANSCRIPTION
-    );
+    const transcriptionService = runtime.getService(ServiceType.TRANSCRIPTION);
     if (!transcriptionService) {
       throw new Error("Transcription service not found");
     }
     const result = await transcriptionService.transcribeAudio(audioBuffer);
     const transcript = result.text;
     const endTime = Date.now();
-    elizaLogger2.log(
-      `Transcription completed in ${(endTime - startTime) / 1e3} seconds`
-    );
+    elizaLogger2.log(`Transcription completed in ${(endTime - startTime) / 1000} seconds`);
     return transcript || "Transcription failed";
   }
   async convertMp4ToMp3(inputPath, outputPath) {
@@ -901,21 +855,21 @@ var VideoService = class _VideoService extends IVideoService {
         elizaLogger2.log("Conversion to MP3 complete");
         resolve();
       }).on("error", (err) => {
-        elizaLogger2.log("Error converting to MP3:", err);
+        elizaLogger2.log("Error converting to MP3:", loggableError(err));
         reject(err);
       }).run();
     });
   }
   async downloadAudio(url, outputFile) {
     elizaLogger2.log("Downloading audio");
-    outputFile = outputFile ?? path2.join(this.dataDir, `${this.getVideoId(url)}.mp3`);
     try {
       if (url.endsWith(".mp4") || url.includes(".mp4?")) {
-        elizaLogger2.log(
-          "Direct MP4 file detected, downloading and converting to MP3"
-        );
+        elizaLogger2.log("Direct MP4 file detected, downloading and converting to MP3");
         const tempMp4File = path2.join(tmpdir(), `${this.getVideoId(url)}.mp4`);
         const response = await fetch(url);
+        if (!response.ok) {
+          throw new Error(`Failed to download MP4: ${response.status} ${response.statusText}`);
+        }
         const arrayBuffer = await response.arrayBuffer();
         const buffer = Buffer.from(arrayBuffer);
         fs.writeFileSync(tempMp4File, buffer);
@@ -929,9 +883,7 @@ var VideoService = class _VideoService extends IVideoService {
           }).run();
         });
       } else {
-        elizaLogger2.log(
-          "YouTube video detected, downloading audio with youtube-dl"
-        );
+        elizaLogger2.log("YouTube video detected, downloading audio with youtube-dl");
         await this.binaries.runYtDlp(url, {
           verbose: true,
           extractAudio: true,
@@ -942,11 +894,11 @@ var VideoService = class _VideoService extends IVideoService {
       }
       return outputFile;
     } catch (error) {
-      elizaLogger2.log("Error downloading audio:", error);
+      elizaLogger2.log("Error downloading audio:", loggableError(error));
       throw new Error("Failed to download audio");
     }
   }
-};
+}
 
 // src/index.ts
 var videoPlugin = {
@@ -955,10 +907,15 @@ var videoPlugin = {
   services: [VideoService],
   actions: [],
   providers: [],
-  routes: []
+  routes: [],
+  async dispose(runtime) {
+    const svc = runtime.getService(VideoService.serviceType);
+    await svc?.stop();
+  }
 };
-var index_default = videoPlugin;
+var src_default = videoPlugin;
 export {
-  index_default as default
+  src_default as default
 };
-//# sourceMappingURL=index.js.map
+
+//# debugId=17A8C3F43B7ECE4364756E2164756E21