@vm0/cli 9.249.1 → 9.249.2

package/{chunk-L63QVTYZ.js → chunk-BQOOTJNB.js}

@@ -2,12 +2,13 @@
 import { createRequire as __createRequire } from "node:module";
 const require = __createRequire(import.meta.url);
 import {
-  decodeZeroTokenPayload
-} from "./chunk-LRHXR7JT.js";
+  decodeZeroTokenPayload,
+  isFeatureEnabled
+} from "./chunk-A2NKQGRI.js";
 import {
   __export,
   init_esm_shims
-} from "./chunk-DIRAZ3YX.js";
+} from "./chunk-3VVCUQPB.js";
 
 // ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
 init_esm_shims();
@@ -15384,7 +15385,7 @@ function createCliClientHeaderInjector(options) {
   };
 }
 var addDefaultCliClientHeaders = createCliClientHeaderInjector({
-  clientVersion: "9.249.1"
+  clientVersion: "9.249.2"
 });
 function addCliClientHeaders(headers) {
   addDefaultCliClientHeaders(headers);
@@ -16496,6 +16497,8 @@ var apiErrorSchema = external_exports.object({
     code: external_exports.string()
   })
 });
+var PLAN_UPGRADE_RUN_GUIDANCE = "Return the plan upgrade link to the user.";
+var PLAN_UPGRADE_CLI_HINT = "zero upgrade pro";
 var RUN_ERROR_GUIDANCE = {
   COMPUTER_USE_AUTHORIZATION_REQUIRED: {
     title: "Computer Use authorization required",
@@ -16509,7 +16512,12 @@ var RUN_ERROR_GUIDANCE = {
   },
   INSUFFICIENT_CREDITS: {
     title: "Credits depleted",
-    guidance: "Add credits or configure your own API key to continue."
+    guidance: "Run credit diagnostics first. Buy credits only when the current plan allows it; otherwise return the plan upgrade link.",
+    cliHint: "zero doctor credit"
+  },
+  PRO_REQUIRED: {
+    title: "Paid plan required",
+    guidance: "Built-in video generation is unavailable on the current plan."
   },
   PROVIDER_INCOMPATIBLE: {
     title: "Provider not compatible",
@@ -16572,6 +16580,13 @@ var ACTIONABLE_RUN_ERROR_SNIPPETS = [
 ];
 
 // src/lib/command/with-error-handler.ts
+function isPlanUpgradeGuidanceEnabled() {
+  const payload = decodeZeroTokenPayload();
+  return isFeatureEnabled("planUpgradeGuidance" /* PlanUpgradeGuidance */, {
+    userId: payload?.userId,
+    orgId: payload?.orgId
+  });
+}
 function withErrorHandler(fn) {
   return async (...args) => {
     try {
@@ -16589,10 +16604,13 @@ function withErrorHandler(fn) {
         } else {
           const guidance = RUN_ERROR_GUIDANCE[error48.code];
           if (guidance) {
+            const showPlanUpgradeGuidance = error48.code === "PRO_REQUIRED" && isPlanUpgradeGuidanceEnabled();
+            const guidanceText = showPlanUpgradeGuidance ? `${guidance.guidance} ${PLAN_UPGRADE_RUN_GUIDANCE}` : guidance.guidance;
+            const cliHint = showPlanUpgradeGuidance ? PLAN_UPGRADE_CLI_HINT : guidance.cliHint;
             console.error(source_default.red(`\u2717 ${guidance.title}`));
-            console.error(source_default.dim(`  ${guidance.guidance}`));
-            if (guidance.cliHint) {
-              console.error(source_default.dim(`  Run: ${guidance.cliHint}`));
+            console.error(source_default.dim(`  ${guidanceText}`));
+            if (cliHint) {
+              console.error(source_default.dim(`  Run: ${cliHint}`));
             }
           } else {
             console.error(source_default.red(`\u2717 ${error48.status}: ${error48.message}`));
@@ -16611,662 +16629,6 @@ function withErrorHandler(fn) {
   };
 }
 
-// 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 url2 = new URL("/api/zero/web/download-file", baseUrl);
-  url2.searchParams.set("file_id", fileId);
-  const headers = {
-    Authorization: `Bearer ${token}`
-  };
-  const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
-  if (bypassSecret) {
-    headers["x-vercel-protection-bypass"] = bypassSecret;
-  }
-  const response = await fetch(url2, {
-    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"
-  };
-  const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
-  if (bypassSecret) {
-    headers["x-vercel-protection-bypass"] = bypassSecret;
-  }
-  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 bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
-  if (bypassSecret) {
-    prepareHeaders["x-vercel-protection-bypass"] = bypassSecret;
-  }
-  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 })
-  });
-  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 },
-    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 bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
-  if (bypassSecret) {
-    headers["x-vercel-protection-bypass"] = bypassSecret;
-  }
-  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 bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
-  if (bypassSecret) {
-    headers["x-vercel-protection-bypass"] = bypassSecret;
-  }
-  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 bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
-  if (bypassSecret) {
-    headers["x-vercel-protection-bypass"] = bypassSecret;
-  }
-  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 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 bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
-  if (bypassSecret) {
-    headers["x-vercel-protection-bypass"] = bypassSecret;
-  }
-  const url2 = new URL("/api/zero/voice-io/stt", baseUrl);
-  if (options.verbose) {
-    url2.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(url2, {
-    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 {
   source_default,
   getToken,
@@ -17300,13 +16662,6 @@ export {
   orgModelPoliciesResponseSchema,
   updateOrgModelPoliciesRequestSchema,
   apiErrorSchema,
-  inferWebUploadContentType,
-  downloadWebFile,
-  uploadWebFile,
-  generateWebVoice,
-  generateWebImage,
-  generateWebVideo,
-  transcribeAudio,
   withErrorHandler
 };
-//# sourceMappingURL=chunk-L63QVTYZ.js.map
+//# sourceMappingURL=chunk-BQOOTJNB.js.map