@vercel/python 6.37.0 → 6.38.0

package/dist/index.js

@@ -3231,7 +3231,7 @@ var import_path13 = require("path");
 
 // src/package-versions.ts
 var VERCEL_RUNTIME_VERSION = "0.13.1";
-var VERCEL_WORKERS_VERSION = "0.0.20";
+var VERCEL_WORKERS_VERSION = "0.0.22";
 
 // src/index.ts
 var import_build_utils16 = require("@vercel/build-utils");
@@ -4328,6 +4328,9 @@ var LAMBDA_SIZE_THRESHOLD_BYTES = 245 * 1024 * 1024;
 var LAMBDA_EPHEMERAL_STORAGE_BYTES = 500 * 1024 * 1024;
 var HIVE_LAMBDA_SIZE_BYTES = 1 * 1024 * 1024 * 1024;
 var FUNCTIONS_BETA_CTA = "Run `vercel deploy --functions-beta` to use extended function limits (up to 1 GB), or reduce your dependency footprint.";
+var BUNDLING_DOCS_LINK = "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled";
+var FUNCTIONS_BETA_DOCS_LINK = "https://vercel.com/docs/functions/runtimes/python#extended-size-limits-with-functions-beta";
+var FUNCTIONS_BETA_EXCEEDED_CTA = "Your deployment is already using extended function limits (`--functions-beta`).\nReduce your dependency footprint to under 1 GB or split your application\ninto smaller functions.";
 function shouldShowFunctionsBetaHint() {
   const v = process.env.VERCEL_FUNCTIONS_BETA_HINT;
   return v === "1" || v === "true";
@@ -4390,10 +4393,13 @@ var PythonDependencyExternalizer = class {
 
 ` + FUNCTIONS_BETA_CTA : `Total bundle size (${totalBundleSizeMB} MB) exceeds the size limit (${limitMB} MB).
 
-When using a custom install command, Vercel cannot automatically optimize dependency bundling. To reduce the size of your dependencies, you can:
-  1. Remove unused dependencies from your project
-  2. Remove the custom install command to allow Vercel to manage and optimize dependencies automatically`,
-        link: "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled",
+When using a custom install command, Vercel cannot automatically
+optimize dependency bundling. To reduce the size of your
+dependencies, you can:
+  1. Remove unused dependencies from your project.
+  2. Remove the custom install command to allow Vercel to manage
+     and optimize dependencies automatically.`,
+        link: shouldShowFunctionsBetaHint() ? FUNCTIONS_BETA_DOCS_LINK : BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
@@ -4401,7 +4407,12 @@ When using a custom install command, Vercel cannot automatically optimize depend
       const limitMB = (HIVE_LAMBDA_SIZE_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils5.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the extended function size limit (${limitMB} MB). Consider removing unused dependencies or splitting your application into smaller functions.`,
+        message: shouldShowFunctionsBetaHint() ? `Total bundle size (${totalBundleSizeMB} MB) exceeds the extended function size limit (${limitMB} MB).
+
+` + FUNCTIONS_BETA_EXCEEDED_CTA : `Total bundle size (${totalBundleSizeMB} MB) exceeds the extended function size limit (${limitMB} MB).
+
+Consider removing unused dependencies or splitting your
+application into smaller functions.`,
         link: "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled",
         action: "Learn More"
       });
@@ -4440,8 +4451,13 @@ When using a custom install command, Vercel cannot automatically optimize depend
         code: "LAMBDA_SIZE_EXCEEDED",
         message: shouldShowFunctionsBetaHint() ? `Total bundle size (${totalBundleSizeMB} MB) exceeds the ephemeral storage limit (${ephemeralLimitMB} MB).
 
-` + FUNCTIONS_BETA_CTA : `Total bundle size (${totalBundleSizeMB} MB) exceeds Lambda ephemeral storage limit (${ephemeralLimitMB} MB). Even with runtime dependency installation, all packages must fit within the ${ephemeralLimitMB} MB ephemeral storage available to Lambda functions. Consider removing unused dependencies or splitting your application into smaller functions.`,
-        link: "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled",
+` + FUNCTIONS_BETA_CTA : `Total bundle size (${totalBundleSizeMB} MB) exceeds Lambda ephemeral storage limit (${ephemeralLimitMB} MB).
+
+Even with runtime dependency installation, all packages must fit
+within the ${ephemeralLimitMB} MB ephemeral storage available to Lambda
+functions. Consider removing unused dependencies or splitting
+your application into smaller functions.`,
+        link: shouldShowFunctionsBetaHint() ? FUNCTIONS_BETA_DOCS_LINK : BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
@@ -4513,12 +4529,17 @@ ${error.fileContent}`
     if (externalizablePublic.length === 0) {
       throw new import_build_utils5.NowBuildError({
         code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: `Bundle size exceeds the Lambda limit and requires runtime dependency installation, but no public packages have compatible pre-built wheels for the Lambda platform.
-Runtime dependency installation requires packages to have binary wheels.
+        message: `Bundle size exceeds the Lambda limit and requires runtime
+dependency installation, but no public packages have compatible
+pre-built wheels for the Lambda platform.
+
+Runtime dependency installation requires packages to have binary
+wheels.
 
 To fix this, either:
- 1. Regenerate your lock file with: uv lock --upgrade, or
- 2. Switch the problematic packages to ones that have pre-built wheels available`
+  1. Regenerate your lock file with: uv lock --upgrade, or
+  2. Switch the problematic packages to ones that have pre-built
+     wheels available.`
       });
     }
     const packageSizes = await calculatePerPackageSizes(this.venvPath);
@@ -4636,8 +4657,13 @@ To fix this, either:
         code: "LAMBDA_SIZE_EXCEEDED",
         message: shouldShowFunctionsBetaHint() ? `Total bundle size (${finalSizeMB} MB) exceeds the size limit (${limitMB} MB).
 
-` + FUNCTIONS_BETA_CTA : `Total bundle size (${finalSizeMB} MB) exceeds Lambda limit (${limitMB} MB) even after deferring public packages to runtime installation. This usually means your private packages or source code are too large. Consider reducing the size of private dependencies or splitting your application.`,
-        link: "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled",
+` + FUNCTIONS_BETA_CTA : `Total bundle size (${finalSizeMB} MB) exceeds Lambda limit (${limitMB} MB) even after
+deferring public packages to runtime installation.
+
+This usually means your private packages or source code are too
+large. Consider reducing the size of private dependencies or
+splitting your application.`,
+        link: shouldShowFunctionsBetaHint() ? FUNCTIONS_BETA_DOCS_LINK : BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
@@ -5280,6 +5306,7 @@ var PYTHON_ENTRYPOINT_DIRS = ["", "src", "app", "api"];
 var PYTHON_CANDIDATE_ENTRYPOINTS = getCandidateEntrypointsInDirs(
   PYTHON_ENTRYPOINT_DIRS
 );
+var PYTHON_ENTRYPOINT_DOCS_URL = "https://vercel.com/docs/functions/runtimes/python#python-entrypoints";
 function getCandidateEntrypointsInDirs(dirs) {
   return dirs.flatMap(
     (dir) => PYTHON_ENTRYPOINT_FILENAMES.map(
@@ -5295,6 +5322,51 @@ async function fileExists(filePath) {
     return false;
   }
 }
+function getFrameworkDisplayName(framework) {
+  switch (framework) {
+    case "fastapi":
+      return "FastAPI";
+    case "flask":
+      return "Flask";
+    case "django":
+      return "Django";
+    case "fasthtml":
+      return "FastHTML";
+    default:
+      return framework;
+  }
+}
+function getFrameworkEntrypointDocsUrl(framework) {
+  switch (framework) {
+    case "fastapi":
+      return "https://vercel.com/docs/frameworks/backend/fastapi#exporting-the-fastapi-application";
+    case "flask":
+      return "https://vercel.com/docs/frameworks/backend/flask#exporting-the-flask-application";
+    case "django":
+      return "https://vercel.com/docs/frameworks/full-stack/django#configure-the-django-entrypoint";
+    default:
+      return PYTHON_ENTRYPOINT_DOCS_URL;
+  }
+}
+function getMissingExportMessage(framework, entrypoints) {
+  const fileList = entrypoints.slice(0, 3).join(", ");
+  const found = `Found ${fileList}`;
+  const subject = entrypoints.length === 1 ? "it" : "none";
+  const verb = entrypoints.length === 1 ? "does not define" : "define";
+  const displayName = getFrameworkDisplayName(framework);
+  switch (framework) {
+    case "fastapi":
+      return `${found} but ${subject} ${verb} a top-level "app" FastAPI instance.`;
+    case "flask":
+      return `${found} but ${subject} ${verb} a top-level "app" Flask instance.`;
+    case "django":
+      return `${found} but ${subject} ${verb} a top-level "application" ASGI or WSGI instance.`;
+    case "fasthtml":
+      return `${found} but ${subject} ${verb} a top-level "app" ${displayName} instance.`;
+    default:
+      return entrypoints.length === 1 ? `Found ${fileList} but it does not export a top-level "app", "application", or "handler" variable.` : `Found ${fileList} but none export a top-level "app", "application", or "handler" variable.`;
+  }
+}
 async function checkEntrypoint(workPath, relPath) {
   const absPath = (0, import_path8.join)(workPath, relPath);
   if (!await fileExists(absPath))
@@ -5302,6 +5374,28 @@ async function checkEntrypoint(workPath, relPath) {
   const content = await import_fs8.default.promises.readFile(absPath, "utf-8");
   return (0, import_python_analysis5.findAppOrHandler)(content);
 }
+async function findOtherPyFiles(workPath, dirs, candidateSet) {
+  const results = [];
+  for (const dir of dirs) {
+    const dirPath = (0, import_path8.join)(workPath, dir);
+    try {
+      const entries = await import_fs8.default.promises.readdir(dirPath);
+      for (const entry of entries) {
+        if (!entry.endsWith(".py"))
+          continue;
+        const relPath = dir ? import_path8.posix.join(dir, entry) : entry;
+        if (candidateSet.has(relPath))
+          continue;
+        const stat = await import_fs8.default.promises.stat((0, import_path8.join)(dirPath, entry));
+        if (stat.isFile()) {
+          results.push(relPath);
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
 async function resolveModuleAttrEntrypoint(workPath, value) {
   const match = value.match(/([A-Za-z_][\w.]*)\s*:\s*([A-Za-z_][\w]*)/);
   if (!match)
@@ -5326,25 +5420,46 @@ async function getVercelToolsEntrypoint(workPath) {
     return null;
   return resolveModuleAttrEntrypoint(workPath, vercelEntrypoint);
 }
-async function getPyprojectScriptsEntrypoint(workPath) {
+async function getPyprojectEntrypointWithDiagnostics(workPath) {
   const pyprojectData = await (0, import_build_utils10.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
-    return null;
+    return { entrypoint: null };
   const scripts = pyprojectData.project?.scripts;
   const appScript = scripts?.app;
   if (typeof appScript !== "string")
-    return null;
-  return resolveModuleAttrEntrypoint(workPath, appScript);
+    return { entrypoint: null };
+  const match = appScript.match(/([A-Za-z_][\w.]*)\s*:\s*([A-Za-z_][\w]*)/);
+  if (!match)
+    return { entrypoint: null, appScript };
+  const modulePath = match[1];
+  const variableName = match[2];
+  const relPath = modulePath.replace(/\./g, "/");
+  const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
+  for (const candidate of candidates) {
+    if (await fileExists((0, import_path8.join)(workPath, candidate))) {
+      return { entrypoint: { entrypoint: candidate, variableName } };
+    }
+  }
+  return { entrypoint: null, appScript, checkedPaths: candidates };
 }
 async function findValidEntrypoint(workPath, candidates) {
+  const existingWithoutEntrypoint = [];
   for (const candidate of candidates) {
-    const varName = await checkEntrypoint(workPath, candidate);
+    const absPath = (0, import_path8.join)(workPath, candidate);
+    if (!await fileExists(absPath))
+      continue;
+    const content = await import_fs8.default.promises.readFile(absPath, "utf-8");
+    const varName = await (0, import_python_analysis5.findAppOrHandler)(content);
     if (varName) {
       (0, import_build_utils9.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
-      return { entrypoint: candidate, variableName: varName };
+      return {
+        entrypoint: { entrypoint: candidate, variableName: varName },
+        existingWithoutEntrypoint
+      };
     }
+    existingWithoutEntrypoint.push(candidate);
   }
-  return null;
+  return { entrypoint: null, existingWithoutEntrypoint };
 }
 async function checkDjangoManage(workPath) {
   const managePath = (0, import_path8.join)(workPath, "manage.py");
@@ -5368,28 +5483,56 @@ async function getSubdirectories(workPath) {
     return [];
   }
 }
-function makeDetectError(framework) {
-  const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-  return new import_build_utils8.NowBuildError({
-    code: `${framework.toUpperCase()}_ENTRYPOINT_NOT_FOUND`,
-    message: `No ${framework} entrypoint found. Set \`tool.vercel.entrypoint\` in pyproject.toml or define an entrypoint in one of: ${searchedList}.`,
-    link: `https://vercel.com/docs/frameworks/backend/${framework}#exporting-the-${framework}-application`,
-    action: "Learn More"
-  });
+function makeDiagnosticError(framework, diagnostics2) {
+  const code = `${framework.toUpperCase()}_ENTRYPOINT_NOT_FOUND`;
+  const link = getFrameworkEntrypointDocsUrl(framework);
+  const action = "Learn More";
+  const displayName = getFrameworkDisplayName(framework);
+  let message;
+  if (diagnostics2.existingWithoutEntrypoint.length > 0) {
+    message = getMissingExportMessage(
+      framework,
+      diagnostics2.existingWithoutEntrypoint
+    );
+  } else if (diagnostics2.pyprojectAppScript && diagnostics2.pyprojectCheckedPaths?.length) {
+    const checked = diagnostics2.pyprojectCheckedPaths.join(" or ");
+    message = `pyproject.toml [project.scripts] defines app = "${diagnostics2.pyprojectAppScript}" but ${checked} was not found.`;
+  } else if (diagnostics2.otherPyFiles.length > 0) {
+    const fileList = diagnostics2.otherPyFiles.slice(0, 5).join(", ");
+    message = `No ${displayName} entrypoint found in standard locations. Found Python files: ${fileList}. Rename one to app.py or set "tool.vercel.entrypoint" in pyproject.toml.`;
+  } else {
+    const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
+    message = `No ${displayName} entrypoint found. Set "tool.vercel.entrypoint" in pyproject.toml or define an entrypoint in one of: ${searchedList}.`;
+  }
+  return new import_build_utils8.NowBuildError({ code, message, link, action });
 }
 async function detectGenericPythonEntrypoint(workPath) {
   try {
-    const found = await findValidEntrypoint(
+    const result = await findValidEntrypoint(
       workPath,
       PYTHON_CANDIDATE_ENTRYPOINTS
     );
-    return found ? { entrypoint: found } : null;
+    return {
+      detected: result.entrypoint ? { entrypoint: result.entrypoint } : null,
+      findDiagnostics: result
+    };
   } catch {
     (0, import_build_utils9.debug)("Failed to discover Python entrypoint");
-    return null;
+    return {
+      detected: null,
+      findDiagnostics: { entrypoint: null, existingWithoutEntrypoint: [] }
+    };
   }
 }
 async function detectDjangoPythonEntrypoint(workPath) {
+  const emptyResult = {
+    detected: null,
+    findDiagnostics: {
+      entrypoint: null,
+      existingWithoutEntrypoint: []
+    },
+    dirs: PYTHON_ENTRYPOINT_DIRS
+  };
   try {
     const subdirs = await getSubdirectories(workPath);
     const rootDirs = ["", ...subdirs];
@@ -5397,21 +5540,40 @@ async function detectDjangoPythonEntrypoint(workPath) {
       const currPath = (0, import_path8.join)(workPath, rootDir);
       const isDjango = await checkDjangoManage(currPath);
       if (isDjango) {
-        return { baseDir: rootDir, error: makeDetectError("django") };
+        return {
+          detected: { baseDir: rootDir },
+          findDiagnostics: { entrypoint: null, existingWithoutEntrypoint: [] },
+          dirs: rootDirs
+        };
       }
     }
     const candidates = getCandidateEntrypointsInDirs(rootDirs);
-    const found = await findValidEntrypoint(workPath, candidates);
-    return found ? { entrypoint: found } : null;
+    const result = await findValidEntrypoint(workPath, candidates);
+    return {
+      detected: result.entrypoint ? { entrypoint: result.entrypoint } : null,
+      findDiagnostics: result,
+      dirs: rootDirs
+    };
   } catch {
     (0, import_build_utils9.debug)("Failed to discover Django Python entrypoint");
-    return null;
+    return emptyResult;
   }
 }
 async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint, service) {
   if (configuredEntrypoint) {
     const { filePath: configEntryFile, varName: configEntryVar } = configuredEntrypoint;
     const entrypoint = configEntryFile.endsWith(".py") ? configEntryFile : `${configEntryFile}.py`;
+    const entrypointExists = await fileExists((0, import_path8.join)(workPath, entrypoint));
+    if (!entrypointExists) {
+      return {
+        error: new import_build_utils8.NowBuildError({
+          code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+          message: `Configured Python entrypoint "${entrypoint}" was not found.`,
+          link: PYTHON_ENTRYPOINT_DOCS_URL,
+          action: "Learn More"
+        })
+      };
+    }
     let varName = configEntryVar ?? await checkEntrypoint(workPath, entrypoint);
     if (!varName) {
       const needsDynamicApp = !!service && ((0, import_build_utils8.isScheduleTriggeredService)(service) || (0, import_build_utils8.isQueueTriggeredService)(service));
@@ -5427,7 +5589,7 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
         error: new import_build_utils8.NowBuildError({
           code: "PYTHON_ENTRYPOINT_NOT_FOUND",
           message: `Could not find a top-level "app", "application", or "handler" in "${entrypoint}".`,
-          link: "https://vercel.com/docs/functions/serverless-functions/runtimes/python",
+          link: PYTHON_ENTRYPOINT_DOCS_URL,
           action: "Learn More"
         })
       };
@@ -5439,11 +5601,57 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
   const vercelEntry = await getVercelToolsEntrypoint(workPath);
   if (vercelEntry)
     return { entrypoint: vercelEntry };
-  const result = framework === "django" ? await detectDjangoPythonEntrypoint(workPath) : await detectGenericPythonEntrypoint(workPath);
-  if (result)
-    return result;
-  const scriptsEntry = await getPyprojectScriptsEntrypoint(workPath);
-  return scriptsEntry ? { entrypoint: scriptsEntry } : { error: makeDetectError(framework) };
+  let findDiagnostics;
+  let searchDirs;
+  if (framework === "django") {
+    const djangoResult = await detectDjangoPythonEntrypoint(workPath);
+    findDiagnostics = djangoResult.findDiagnostics;
+    searchDirs = djangoResult.dirs;
+    if (djangoResult.detected) {
+      if (djangoResult.detected.entrypoint)
+        return djangoResult.detected;
+      const candidateSet2 = new Set(getCandidateEntrypointsInDirs(searchDirs));
+      const otherPyFiles2 = await findOtherPyFiles(
+        workPath,
+        searchDirs,
+        candidateSet2
+      );
+      const pyprojectResult2 = await getPyprojectEntrypointWithDiagnostics(workPath);
+      const diagnostics3 = {
+        existingWithoutEntrypoint: findDiagnostics.existingWithoutEntrypoint,
+        otherPyFiles: otherPyFiles2,
+        pyprojectAppScript: pyprojectResult2.appScript,
+        pyprojectCheckedPaths: pyprojectResult2.checkedPaths
+      };
+      return {
+        baseDir: djangoResult.detected.baseDir,
+        error: makeDiagnosticError("django", diagnostics3)
+      };
+    }
+  } else {
+    const genericResult = await detectGenericPythonEntrypoint(workPath);
+    findDiagnostics = genericResult.findDiagnostics;
+    searchDirs = PYTHON_ENTRYPOINT_DIRS;
+    if (genericResult.detected)
+      return genericResult.detected;
+  }
+  const pyprojectResult = await getPyprojectEntrypointWithDiagnostics(workPath);
+  if (pyprojectResult.entrypoint) {
+    return { entrypoint: pyprojectResult.entrypoint };
+  }
+  const candidateSet = new Set(getCandidateEntrypointsInDirs(searchDirs));
+  const otherPyFiles = await findOtherPyFiles(
+    workPath,
+    searchDirs,
+    candidateSet
+  );
+  const diagnostics2 = {
+    existingWithoutEntrypoint: findDiagnostics.existingWithoutEntrypoint,
+    otherPyFiles,
+    pyprojectAppScript: pyprojectResult.appScript,
+    pyprojectCheckedPaths: pyprojectResult.checkedPaths
+  };
+  return { error: makeDiagnosticError(framework, diagnostics2) };
 }
 
 // src/start-dev-server.ts
@@ -6794,6 +7002,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
 // src/index.ts
 var import_python_analysis9 = require("@vercel/python-analysis");
 var writeFile = import_fs13.default.promises.writeFile;
+var PYTHON_ENTRYPOINT_DOCS_URL2 = "https://vercel.com/docs/functions/runtimes/python#python-entrypoints";
 var version = -1;
 async function runFrameworkHook(framework, ctx) {
   const hook = framework ? frameworkHooks[framework] : void 0;
@@ -6881,6 +7090,15 @@ async function downloadFilesInWorkPath({
   (0, import_build_utils16.debug)("Downloading user files...");
   let downloadedFiles = await (0, import_build_utils16.download)(files, workPath, meta);
   if (meta.isDev && entrypoint) {
+    const normalizedEntrypoint = entrypoint.endsWith(".py") ? entrypoint : `${entrypoint}.py`;
+    if (!hasProp(downloadedFiles, entrypoint) && !hasProp(downloadedFiles, normalizedEntrypoint)) {
+      throw new import_build_utils16.NowBuildError({
+        code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+        message: `Configured Python entrypoint "${normalizedEntrypoint}" was not found.`,
+        link: PYTHON_ENTRYPOINT_DOCS_URL2,
+        action: "Learn More"
+      });
+    }
     const { devCacheDir = (0, import_path13.join)(workPath, ".now", "cache") } = meta;
     const cacheKey = (0, import_path13.basename)(entrypoint).replace(/\./g, "_");
     const destCache = (0, import_path13.join)(devCacheDir, cacheKey);
@@ -6986,6 +7204,7 @@ var build = async ({
   const venvPath = service?.name ? (0, import_path13.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path13.join)(workPath, ".vercel", "python", ".venv");
   const hasCachedVenv = import_fs13.default.existsSync((0, import_path13.join)(venvPath, "pyvenv.cfg"));
   const hasCachedUv = import_fs13.default.existsSync(uvCacheDir);
+  const restoredCache = hasCachedVenv && hasCachedUv ? "both" : hasCachedVenv ? "venv" : hasCachedUv ? "uv" : "none";
   if (hasCachedVenv || hasCachedUv) {
     (0, import_build_utils16.debug)(
       `Build cache detected: venv=${hasCachedVenv}, uv-cache=${hasCachedUv}`
@@ -7032,7 +7251,9 @@ var build = async ({
   let uvProjectDir = null;
   let projectName;
   await builderSpan.child(import_build_utils16.BUILDER_INSTALLER_STEP, {
-    installCommand: projectInstallCommand || void 0
+    installCommand: projectInstallCommand || void 0,
+    runtime: "python",
+    "python.cache.restored": restoredCache
   }).trace(async () => {
     if (projectInstallCommand) {
       await import_fs13.default.promises.rm(venvPath, { recursive: true, force: true });
@@ -7343,9 +7564,6 @@ var prepareCache = async ({
   repoRootPath,
   workPath
 }) => {
-  if (process.env.VERCEL_PYTHON_PREPARE_CACHE !== "1") {
-    return {};
-  }
   const root = repoRootPath || workPath;
   const ignore = ["**/*.pyc", "**/__pycache__/**"];
   const uvCacheDir = getUvCacheDir(workPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.37.0",
+  "version": "6.38.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",