@vm0/cli 9.278.0 → 9.278.1

package/chunk-J3ZRXVI6.js

@@ -0,0 +1,740 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+import {
+  zeroAvatarVideoAvatarsResponseSchema,
+  zeroAvatarVideoVoicesResponseSchema
+} from "./chunk-SMPSKBAP.js";
+import {
+  ApiRequestError,
+  getActiveToken,
+  getBaseUrl,
+  headersWithCliClientHeaders
+} from "./chunk-GHKWW4NC.js";
+import {
+  init_esm_shims
+} from "./chunk-AUWSMG4F.js";
+
+// src/lib/api/domains/web.ts
+init_esm_shims();
+import { createWriteStream, readFileSync, statSync } from "fs";
+import { basename, extname } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import { setTimeout as delay } from "timers/promises";
+import { Realtime } from "ably";
+var BUILT_IN_GENERATION_POLL_INTERVAL_MS = 2e3;
+var BUILT_IN_GENERATION_WAIT_TIMEOUT_MS_BY_TYPE = {
+  image: 15 * 60 * 1e3,
+  video: 30 * 60 * 1e3,
+  presentation: 60 * 60 * 1e3,
+  website: 60 * 60 * 1e3
+};
+var ABLY_CONNECT_TIMEOUT_MS = 1e4;
+var MIME_BY_EXTENSION = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".heic": "image/heic",
+  ".heif": "image/heif",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff",
+  ".psd": "image/vnd.adobe.photoshop",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".aac": "audio/aac",
+  ".flac": "audio/flac",
+  ".m4a": "audio/mp4",
+  ".mp3": "audio/mpeg",
+  ".mpga": "audio/mpga",
+  ".oga": "audio/ogg",
+  ".ogg": "audio/ogg",
+  ".opus": "audio/opus",
+  ".wav": "audio/wav",
+  ".wave": "audio/wave",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".csv": "text/csv",
+  ".md": "text/markdown",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".json": "application/json",
+  ".xml": "application/xml",
+  ".yaml": "application/yaml",
+  ".yml": "application/yaml",
+  ".tsv": "text/tab-separated-values",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".docm": "application/vnd.ms-word.document.macroenabled.12",
+  ".dotm": "application/vnd.ms-word.template.macroenabled.12",
+  ".dotx": "application/vnd.openxmlformats-officedocument.wordprocessingml.template",
+  ".odt": "application/vnd.oasis.opendocument.text",
+  ".rtf": "application/rtf",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".xlsb": "application/vnd.ms-excel.sheet.binary.macroenabled.12",
+  ".xlsm": "application/vnd.ms-excel.sheet.macroenabled.12",
+  ".xltm": "application/vnd.ms-excel.template.macroenabled.12",
+  ".xltx": "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
+  ".ods": "application/vnd.oasis.opendocument.spreadsheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".potm": "application/vnd.ms-powerpoint.template.macroenabled.12",
+  ".potx": "application/vnd.openxmlformats-officedocument.presentationml.template",
+  ".odp": "application/vnd.oasis.opendocument.presentation",
+  ".ppsx": "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
+  ".ppsm": "application/vnd.ms-powerpoint.slideshow.macroenabled.12",
+  ".pptm": "application/vnd.ms-powerpoint.presentation.macroenabled.12",
+  ".zip": "application/zip",
+  ".rar": "application/vnd.rar",
+  ".7z": "application/x-7z-compressed",
+  ".tar": "application/x-tar",
+  ".gz": "application/gzip",
+  ".tgz": "application/gzip",
+  ".bz2": "application/x-bzip2",
+  ".xz": "application/x-xz",
+  ".pages": "application/vnd.apple.pages",
+  ".numbers": "application/vnd.apple.numbers",
+  ".key": "application/vnd.apple.keynote",
+  ".parquet": "application/vnd.apache.parquet",
+  ".sqlite": "application/vnd.sqlite3",
+  ".sqlite3": "application/vnd.sqlite3",
+  ".db": "application/vnd.sqlite3",
+  ".epub": "application/epub+zip",
+  ".ai": "application/postscript"
+};
+function inferWebUploadContentType(localPath) {
+  const ext = extname(localPath).toLowerCase();
+  return MIME_BY_EXTENSION[ext] ?? "application/octet-stream";
+}
+async function downloadWebFile(fileId, outPath) {
+  const baseUrl = await getBaseUrl();
+  const token = await getActiveToken();
+  if (!token) {
+    throw new ApiRequestError("Not authenticated", "UNAUTHORIZED", 401);
+  }
+  const url = new URL("/api/zero/web/download-file", baseUrl);
+  url.searchParams.set("file_id", fileId);
+  const headers = {
+    Authorization: `Bearer ${token}`
+  };
+  const response = await fetch(url, {
+    headers: headersWithCliClientHeaders(headers)
+  });
+  if (!response.ok) {
+    let message = `Failed to download web file (HTTP ${response.status})`;
+    let code = "UNKNOWN";
+    try {
+      const body = await response.json();
+      if (body.error?.message) message = body.error.message;
+      if (body.error?.code) code = body.error.code;
+    } catch {
+    }
+    throw new ApiRequestError(message, code, response.status);
+  }
+  if (!response.body) {
+    throw new ApiRequestError(
+      "Web download response has no body",
+      "EMPTY_BODY",
+      502
+    );
+  }
+  const mimetype = response.headers.get("x-file-mimetype") ?? response.headers.get("content-type") ?? "application/octet-stream";
+  await pipeline(
+    Readable.fromWeb(response.body),
+    createWriteStream(outPath)
+  );
+  const contentLengthHeader = response.headers.get("content-length");
+  const size = contentLengthHeader ? Number(contentLengthHeader) : 0;
+  return { path: outPath, mimetype, size };
+}
+function shouldIncludePayloadValue(value) {
+  if (value === void 0) {
+    return false;
+  }
+  return !Array.isArray(value) || value.length > 0;
+}
+function compactPayload(entries) {
+  return Object.fromEntries(
+    entries.filter(([, value]) => {
+      return shouldIncludePayloadValue(value);
+    })
+  );
+}
+function generateWebVideoPayload(options) {
+  return compactPayload([
+    ["prompt", options.prompt],
+    ["model", options.model],
+    ["aspectRatio", options.aspectRatio],
+    ["duration", options.duration],
+    ["resolution", options.resolution],
+    ["generateAudio", options.generateAudio],
+    ["negativePrompt", options.negativePrompt],
+    ["seed", options.seed],
+    ["autoFix", options.autoFix],
+    ["safetyTolerance", options.safetyTolerance],
+    ["imageUrls", options.imageUrls],
+    ["videoUrls", options.videoUrls],
+    ["audioUrls", options.audioUrls],
+    ["firstFrameImageUrl", options.firstFrameImageUrl],
+    ["lastFrameImageUrl", options.lastFrameImageUrl]
+  ]);
+}
+async function parseErrorBody(response, fallback) {
+  let message = `${fallback} (HTTP ${response.status})`;
+  let code = "UNKNOWN";
+  try {
+    const body = await response.json();
+    if (body.error?.message) message = body.error.message;
+    if (body.error?.code) code = body.error.code;
+  } catch {
+  }
+  return { message, code };
+}
+function authenticatedJsonHeaders(token) {
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  return headersWithCliClientHeaders(headers);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isBuiltInGenerationAcceptedResponse(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.generationId === "string" && value.status === "queued" && (value.type === "image" || value.type === "video" || value.type === "presentation" || value.type === "website") && isRecord(value.realtime);
+}
+function createBuiltInGenerationRealtime(accepted) {
+  let nextAuthRequest = accepted.realtime.tokenRequest;
+  const authCallback = (_params, callback) => {
+    const current = nextAuthRequest;
+    nextAuthRequest = accepted.realtime.tokenRequest;
+    callback(null, current);
+  };
+  return new Realtime({
+    authCallback,
+    autoConnect: true,
+    disconnectedRetryTimeout: 5e3,
+    suspendedRetryTimeout: 15e3
+  });
+}
+function waitForRealtimeConnected(ably, timeoutMs = ABLY_CONNECT_TIMEOUT_MS) {
+  if (ably.connection.state === "connected") {
+    return Promise.resolve();
+  }
+  if (ably.connection.state === "failed") {
+    return Promise.reject(new Error("Ably connection failed"));
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error("Timed out connecting to Ably"));
+    }, timeoutMs);
+    ably.connection.once("connected", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    ably.connection.once("failed", (stateChange) => {
+      clearTimeout(timer);
+      reject(
+        new Error(
+          `Ably connection failed: ${stateChange?.reason?.message ?? "unknown"}`
+        )
+      );
+    });
+  });
+}
+async function createBuiltInGenerationNotifier(accepted) {
+  const ably = createBuiltInGenerationRealtime(accepted);
+  try {
+    await waitForRealtimeConnected(ably);
+    const channel = ably.channels.get(accepted.realtime.channelName);
+    let pendingEvent = false;
+    let closed = false;
+    let wake = null;
+    const wakeWaiter = () => {
+      const current = wake;
+      wake = null;
+      current?.();
+    };
+    const onMessage = (_message) => {
+      if (wake) {
+        wakeWaiter();
+        return;
+      }
+      pendingEvent = true;
+    };
+    await channel.subscribe(accepted.realtime.eventName, onMessage);
+    return {
+      wait(timeoutMs) {
+        if (pendingEvent || closed || timeoutMs <= 0) {
+          pendingEvent = false;
+          return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+          function done() {
+            clearTimeout(timer);
+            if (wake === done) {
+              wake = null;
+            }
+            resolve();
+          }
+          const timer = setTimeout(done, timeoutMs);
+          wake = done;
+        });
+      },
+      close() {
+        if (closed) {
+          return;
+        }
+        closed = true;
+        channel.unsubscribe(accepted.realtime.eventName, onMessage);
+        wakeWaiter();
+        ably.close();
+      }
+    };
+  } catch {
+    ably.close();
+    return null;
+  }
+}
+async function getBuiltInGenerationStatus(baseUrl, token, generationId) {
+  const response = await fetch(
+    new URL(`/api/zero/built-in-generations/${generationId}`, baseUrl),
+    { headers: authenticatedJsonHeaders(token) }
+  );
+  if (!response.ok) {
+    const { message, code } = await parseErrorBody(
+      response,
+      "Failed to get generation status"
+    );
+    throw new ApiRequestError(message, code, response.status);
+  }
+  return await response.json();
+}
+function readBuiltInGenerationResult(status, fallback) {
+  if (status.status === "completed") {
+    if (!status.result) {
+      throw new ApiRequestError(
+        `${fallback} returned no result`,
+        "EMPTY_RESULT",
+        502
+      );
+    }
+    return status.result;
+  }
+  if (status.status === "failed") {
+    const code = status.error?.code ?? "GENERATION_FAILED";
+    throw new ApiRequestError(
+      status.error?.message ?? `${fallback} failed`,
+      code,
+      statusForBuiltInGenerationError(code)
+    );
+  }
+  return void 0;
+}
+function statusForBuiltInGenerationError(code) {
+  if (code === "BAD_REQUEST") {
+    return 400;
+  }
+  if (code === "INSUFFICIENT_CREDITS") {
+    return 402;
+  }
+  if (code === "NOT_CONFIGURED") {
+    return 503;
+  }
+  if (code === "GENERATION_TIMEOUT") {
+    return 504;
+  }
+  if (code.startsWith("BYTEPLUS_INVALID_PARAMETER") || code.startsWith("BYTEPLUS_INPUT_")) {
+    return 400;
+  }
+  if (code.startsWith("BYTEPLUS_")) {
+    return 502;
+  }
+  if (code.startsWith("NO_") || code.endsWith("_FAILED")) {
+    return 502;
+  }
+  return 500;
+}
+async function waitForBuiltInGenerationResult(args) {
+  let notifier = null;
+  let notifierCreated = false;
+  const startedAt = Date.now();
+  const timeoutMs = BUILT_IN_GENERATION_WAIT_TIMEOUT_MS_BY_TYPE[args.accepted.type];
+  try {
+    while (Date.now() - startedAt < timeoutMs) {
+      const status = await getBuiltInGenerationStatus(
+        args.baseUrl,
+        args.token,
+        args.accepted.generationId
+      );
+      const result = readBuiltInGenerationResult(status, args.fallback);
+      if (result) {
+        return result;
+      }
+      const elapsed = Date.now() - startedAt;
+      const remaining = timeoutMs - elapsed;
+      const waitMs = Math.min(BUILT_IN_GENERATION_POLL_INTERVAL_MS, remaining);
+      if (!notifierCreated) {
+        notifier = await createBuiltInGenerationNotifier(args.accepted);
+        notifierCreated = true;
+      }
+      if (notifier) {
+        await notifier.wait(waitMs);
+      } else {
+        await delay(waitMs);
+      }
+    }
+  } finally {
+    notifier?.close();
+  }
+  throw new ApiRequestError(
+    `${args.fallback} timed out (generationId: ${args.accepted.generationId})`,
+    "GENERATION_TIMEOUT",
+    504
+  );
+}
+async function readBuiltInGenerationResponse(args) {
+  const body = await args.response.json();
+  if (isBuiltInGenerationAcceptedResponse(body)) {
+    return waitForBuiltInGenerationResult({
+      accepted: body,
+      baseUrl: args.baseUrl,
+      token: args.token,
+      fallback: args.fallback
+    });
+  }
+  if (args.response.status === 202) {
+    throw new ApiRequestError(
+      `${args.fallback} returned an invalid generation response`,
+      "INVALID_GENERATION_RESPONSE",
+      502
+    );
+  }
+  return body;
+}
+async function uploadWebFile(localPath, options) {
+  const stats = statSync(localPath);
+  if (!stats.isFile()) {
+    throw new ApiRequestError(
+      `Not a regular file: ${localPath}`,
+      "BAD_REQUEST",
+      400
+    );
+  }
+  const baseUrl = await getBaseUrl();
+  const token = await getActiveToken();
+  if (!token) {
+    throw new ApiRequestError("Not authenticated", "UNAUTHORIZED", 401);
+  }
+  const filename = basename(localPath);
+  const contentType = options?.contentType ?? inferWebUploadContentType(localPath);
+  const prepareHeaders = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  const prepareUrl = new URL("/api/zero/uploads/prepare", baseUrl);
+  const prepareRes = await fetch(prepareUrl, {
+    method: "POST",
+    headers: headersWithCliClientHeaders(prepareHeaders),
+    body: JSON.stringify({
+      filename,
+      contentType,
+      size: stats.size,
+      supportsUploadHeaders: true
+    })
+  });
+  if (!prepareRes.ok) {
+    const { message, code } = await parseErrorBody(
+      prepareRes,
+      "Failed to prepare upload"
+    );
+    throw new ApiRequestError(message, code, prepareRes.status);
+  }
+  const prepared = await prepareRes.json();
+  const bytes = readFileSync(localPath);
+  const putRes = await fetch(prepared.uploadUrl, {
+    method: "PUT",
+    headers: {
+      "Content-Type": prepared.contentType,
+      ...prepared.uploadHeaders
+    },
+    body: new Uint8Array(bytes)
+  });
+  if (!putRes.ok) {
+    throw new ApiRequestError(
+      `Failed to upload file to storage (HTTP ${putRes.status})`,
+      "UPLOAD_FAILED",
+      putRes.status
+    );
+  }
+  const completeUrl = new URL("/api/zero/uploads/complete", baseUrl);
+  const completeRes = await fetch(completeUrl, {
+    method: "POST",
+    headers: headersWithCliClientHeaders(prepareHeaders),
+    body: JSON.stringify({
+      id: prepared.id,
+      contentType: prepared.contentType
+    })
+  });
+  if (!completeRes.ok) {
+    const { message, code } = await parseErrorBody(
+      completeRes,
+      "Failed to complete upload"
+    );
+    throw new ApiRequestError(message, code, completeRes.status);
+  }
+  const completed = await completeRes.json();
+  return {
+    id: completed.id,
+    filename: completed.filename,
+    contentType: completed.contentType,
+    size: completed.size,
+    url: completed.url
+  };
+}
+async function generateWebVoice(options) {
+  const baseUrl = await getBaseUrl();
+  const token = await getActiveToken();
+  if (!token) {
+    throw new ApiRequestError("Not authenticated", "UNAUTHORIZED", 401);
+  }
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  const response = await fetch(new URL("/api/zero/voice-io/speech", baseUrl), {
+    method: "POST",
+    headers: headersWithCliClientHeaders(headers),
+    body: JSON.stringify({
+      text: options.text,
+      ...options.voice ? { voice: options.voice } : {},
+      ...options.instructions ? { instructions: options.instructions } : {}
+    })
+  });
+  if (!response.ok) {
+    const { message, code } = await parseErrorBody(
+      response,
+      "Failed to generate voice"
+    );
+    throw new ApiRequestError(message, code, response.status);
+  }
+  return await response.json();
+}
+async function generateWebImage(options) {
+  const baseUrl = await getBaseUrl();
+  const token = await getActiveToken();
+  if (!token) {
+    throw new ApiRequestError("Not authenticated", "UNAUTHORIZED", 401);
+  }
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  const response = await fetch(
+    new URL("/api/zero/image-io/generate", baseUrl),
+    {
+      method: "POST",
+      headers: headersWithCliClientHeaders(headers),
+      body: JSON.stringify({
+        prompt: options.prompt,
+        ...options.model ? { model: options.model } : {},
+        ...options.size ? { size: options.size } : {},
+        ...options.quality ? { quality: options.quality } : {},
+        ...options.background ? { background: options.background } : {},
+        ...options.outputFormat ? { outputFormat: options.outputFormat } : {},
+        ...options.outputCompression !== void 0 ? { outputCompression: options.outputCompression } : {},
+        ...options.moderation ? { moderation: options.moderation } : {},
+        ...options.seed !== void 0 ? { seed: options.seed } : {},
+        ...options.safetyTolerance ? { safetyTolerance: options.safetyTolerance } : {},
+        ...options.enhancePrompt !== void 0 ? { enhancePrompt: options.enhancePrompt } : {},
+        ...options.imageUrls && options.imageUrls.length > 0 ? { imageUrls: options.imageUrls } : {},
+        ...options.maskImageUrl ? { maskImageUrl: options.maskImageUrl } : {},
+        ...options.inputFidelity ? { inputFidelity: options.inputFidelity } : {},
+        ...options.imagePromptStrength !== void 0 ? { imagePromptStrength: options.imagePromptStrength } : {}
+      })
+    }
+  );
+  if (!response.ok) {
+    const { message, code } = await parseErrorBody(
+      response,
+      "Failed to generate image"
+    );
+    throw new ApiRequestError(message, code, response.status);
+  }
+  return readBuiltInGenerationResponse({
+    response,
+    baseUrl,
+    token,
+    fallback: "Failed to generate image"
+  });
+}
+async function generateWebVideo(options) {
+  const baseUrl = await getBaseUrl();
+  const token = await getActiveToken();
+  if (!token) {
+    throw new ApiRequestError("Not authenticated", "UNAUTHORIZED", 401);
+  }
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  const response = await fetch(
+    new URL("/api/zero/video-io/generate", baseUrl),
+    {
+      method: "POST",
+      headers: headersWithCliClientHeaders(headers),
+      body: JSON.stringify(generateWebVideoPayload(options))
+    }
+  );
+  if (!response.ok) {
+    const { message, code } = await parseErrorBody(
+      response,
+      "Failed to generate video"
+    );
+    throw new ApiRequestError(message, code, response.status);
+  }
+  return readBuiltInGenerationResponse({
+    response,
+    baseUrl,
+    token,
+    fallback: "Failed to generate video"
+  });
+}
+async function generateWebAvatarVideo(options) {
+  const baseUrl = await getBaseUrl();
+  const token = await getActiveToken();
+  if (!token) {
+    throw new ApiRequestError("Not authenticated", "UNAUTHORIZED", 401);
+  }
+  const response = await fetch(
+    new URL("/api/zero/avatar-video/generate", baseUrl),
+    {
+      method: "POST",
+      headers: headersWithCliClientHeaders({
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify(options)
+    }
+  );
+  if (!response.ok) {
+    const { message, code } = await parseErrorBody(
+      response,
+      "Failed to generate avatar video"
+    );
+    throw new ApiRequestError(message, code, response.status);
+  }
+  return readBuiltInGenerationResponse({
+    response,
+    baseUrl,
+    token,
+    fallback: "Failed to generate avatar video"
+  });
+}
+function avatarVideoCollectionUrl(baseUrl, collection, query) {
+  const url = new URL(`/api/zero/avatar-video/${collection}`, baseUrl);
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url;
+}
+async function getAvatarVideoCollection(url, fallback) {
+  const token = await getActiveToken();
+  if (!token) {
+    throw new ApiRequestError("Not authenticated", "UNAUTHORIZED", 401);
+  }
+  const response = await fetch(url, {
+    headers: headersWithCliClientHeaders({
+      Authorization: `Bearer ${token}`
+    })
+  });
+  if (!response.ok) {
+    const { message, code } = await parseErrorBody(response, fallback);
+    throw new ApiRequestError(message, code, response.status);
+  }
+  return await response.json();
+}
+async function listWebAvatarVideoAvatars(query) {
+  const baseUrl = await getBaseUrl();
+  return zeroAvatarVideoAvatarsResponseSchema.parse(
+    await getAvatarVideoCollection(
+      avatarVideoCollectionUrl(baseUrl, "avatars", query),
+      "Failed to list JoggAI avatars"
+    )
+  );
+}
+async function listWebAvatarVideoVoices(query) {
+  const baseUrl = await getBaseUrl();
+  return zeroAvatarVideoVoicesResponseSchema.parse(
+    await getAvatarVideoCollection(
+      avatarVideoCollectionUrl(baseUrl, "voices", query),
+      "Failed to list JoggAI voices"
+    )
+  );
+}
+async function transcribeAudio(audioPath, options = {}) {
+  const baseUrl = await getBaseUrl();
+  const token = await getActiveToken();
+  if (!token) {
+    throw new ApiRequestError("Not authenticated", "UNAUTHORIZED", 401);
+  }
+  const headers = {
+    Authorization: `Bearer ${token}`
+  };
+  const url = new URL("/api/zero/voice-io/stt", baseUrl);
+  if (options.verbose) {
+    url.searchParams.set("verbose", "true");
+  }
+  const audioData = readFileSync(audioPath);
+  const filename = basename(audioPath);
+  const ext = extname(filename).toLowerCase();
+  const mimeMap = {
+    ".mp3": "audio/mpeg",
+    ".mp4": "audio/mp4",
+    ".m4a": "audio/m4a",
+    ".wav": "audio/wav",
+    ".webm": "audio/webm"
+  };
+  const mimeType = mimeMap[ext] ?? "audio/mpeg";
+  const formData = new FormData();
+  formData.append("file", new Blob([audioData], { type: mimeType }), filename);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: headersWithCliClientHeaders(headers),
+    body: formData
+  });
+  if (!response.ok) {
+    const { message, code } = await parseErrorBody(
+      response,
+      "Transcription failed"
+    );
+    throw new ApiRequestError(message, code, response.status);
+  }
+  return await response.json();
+}
+
+export {
+  inferWebUploadContentType,
+  downloadWebFile,
+  uploadWebFile,
+  generateWebVoice,
+  generateWebImage,
+  generateWebVideo,
+  generateWebAvatarVideo,
+  listWebAvatarVideoAvatars,
+  listWebAvatarVideoVoices,
+  transcribeAudio
+};
+//# sourceMappingURL=chunk-J3ZRXVI6.js.map