@huggingface/transformers 4.0.0-next.5 → 4.0.0-next.7

package/src/utils/hub/{files.js → FileResponse.js}

@@ -1,5 +1,4 @@
 import fs from 'node:fs';
-import path from 'node:path';
 
 /**
  * Mapping from file extensions to MIME types.
@@ -120,107 +119,3 @@ export class FileResponse {
         return JSON.parse(await this.text());
     }
 }
-
-/**
- * File system cache implementation that implements the CacheInterface.
- * Provides `match` and `put` methods compatible with the Web Cache API.
- */
-export class FileCache {
-    /**
-     * Instantiate a `FileCache` object.
-     * @param {string} path
-     */
-    constructor(path) {
-        this.path = path;
-    }
-
-    /**
-     * Checks whether the given request is in the cache.
-     * @param {string} request
-     * @returns {Promise<FileResponse | undefined>}
-     */
-    async match(request) {
-        let filePath = path.join(this.path, request);
-        let file = new FileResponse(filePath);
-
-        if (file.exists) {
-            return file;
-        } else {
-            return undefined;
-        }
-    }
-
-    /**
-     * Adds the given response to the cache.
-     * @param {string} request
-     * @param {Response} response
-     * @param {(data: {progress: number, loaded: number, total: number}) => void} [progress_callback] Optional.
-     * The function to call with progress updates
-     * @returns {Promise<void>}
-     */
-    async put(request, response, progress_callback = undefined) {
-        let filePath = path.join(this.path, request);
-
-        try {
-            const contentLength = response.headers.get('Content-Length');
-            const total = parseInt(contentLength ?? '0');
-            let loaded = 0;
-
-            await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
-            const fileStream = fs.createWriteStream(filePath);
-            const reader = response.body.getReader();
-
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    break;
-                }
-
-                await new Promise((resolve, reject) => {
-                    fileStream.write(value, (err) => {
-                        if (err) {
-                            reject(err);
-                            return;
-                        }
-                        resolve();
-                    });
-                });
-
-                loaded += value.length;
-                const progress = total ? (loaded / total) * 100 : 0;
-
-                progress_callback?.({ progress, loaded, total });
-            }
-
-            fileStream.close();
-        } catch (error) {
-            // Clean up the file if an error occurred during download
-            try {
-                await fs.promises.unlink(filePath);
-            } catch {}
-            throw error;
-        }
-    }
-
-    /**
-     * Deletes the cache entry for the given request.
-     * @param {string} request
-     * @returns {Promise<boolean>} A Promise that resolves to `true` if the cache entry was deleted, `false` otherwise.
-     */
-    async delete(request) {
-        let filePath = path.join(this.path, request);
-
-        try {
-            await fs.promises.unlink(filePath);
-            return true;
-        } catch (error) {
-            // File doesn't exist or couldn't be deleted
-            return false;
-        }
-    }
-
-    // TODO add the rest?
-    // addAll(requests: RequestInfo[]): Promise<void>;
-    // keys(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<ReadonlyArray<Request>>;
-    // matchAll(request?: RequestInfo | URL, options?: CacheQueryOptions): Promise<ReadonlyArray<Response>>;
-}

package/src/utils/hub/utils.js

@@ -80,7 +80,7 @@ export function handleError(status, remoteURL, fatal) {
 /**
  * Read and track progress when reading a Response object
  *
- * @param {Response|import('./files.js').FileResponse} response The Response object to read
+ * @param {Response|import('./FileResponse.js').FileResponse} response The Response object to read
  * @param {(data: {progress: number, loaded: number, total: number}) => void} progress_callback The function to call with progress updates
  * @param {number} [expectedSize] The expected size of the file (used when content-length header is missing)
  * @returns {Promise<Uint8Array>} A Promise that resolves with the Uint8Array buffer
@@ -132,3 +132,37 @@ export async function readResponse(response, progress_callback, expectedSize) {
 
     return buffer;
 }
+
+/**
+ * Checks if the given URL is a blob URL (created via URL.createObjectURL).
+ * Blob URLs should not be cached as they are temporary in-memory references.
+ * @param {string} url - The URL to check.
+ * @returns {boolean} True if the URL is a blob URL, false otherwise.
+ */
+export function isBlobURL(url) {
+    return isValidUrl(url, ['blob:']);
+}
+
+/**
+ * Converts any URL to an absolute URL if needed.
+ * If the URL is already absolute (http://, https://, or blob:), returns it unchanged (handled by new URL(...)).
+ * Otherwise, resolves it relative to the current page location (browser) or module location (Node/Bun/Deno).
+ * @param {string} url - The URL to convert (can be relative or absolute).
+ * @returns {string} The absolute URL.
+ */
+export function toAbsoluteURL(url) {
+    let baseURL;
+
+    if (typeof location !== 'undefined' && location.href) {
+        // Browser environment: use location.href
+        baseURL = location.href;
+    } else if (typeof import.meta !== 'undefined' && import.meta.url) {
+        // Node.js/Bun/Deno module environment: use import.meta.url
+        baseURL = import.meta.url;
+    } else {
+        // Fallback: if no base is available, return the URL unchanged
+        return url;
+    }
+
+    return new URL(url, baseURL).href;
+}

package/src/utils/hub.js

@@ -6,7 +6,8 @@
 
 import { apis, env } from '../env.js';
 import { dispatchCallback } from './core.js';
-import { FileResponse, FileCache } from './hub/files.js';
+import { FileResponse } from './hub/FileResponse.js';
+import { FileCache } from './cache/FileCache.js';
 import { handleError, isValidUrl, pathJoin, isValidHfModelId, readResponse } from './hub/utils.js';
 import { getCache, tryCache } from './cache.js';
 import { get_file_metadata } from './model_registry/get_file_metadata.js';
@@ -39,7 +40,7 @@ export { MAX_EXTERNAL_DATA_CHUNKS } from './hub/constants.js';
  * @typedef {Object} ModelSpecificPretrainedOptions Options for loading a pretrained model.
  * @property {string} [subfolder='onnx'] In case the relevant files are located inside a subfolder of the model repo on huggingface.co,
  * you can specify the folder name here.
- * @property {string} [model_file_name=null] If specified, load the model with this name (excluding the .onnx suffix). Currently only valid for encoder- or decoder-only models.
+ * @property {string} [model_file_name=null] If specified, load the model with this name (excluding the dtype and .onnx suffixes). Currently only valid for encoder- or decoder-only models.
  * @property {import("./devices.js").DeviceType|Record<string, import("./devices.js").DeviceType>} [device=null] The device to run the model on. If not specified, the device will be chosen from the environment settings.
  * @property {import("./dtypes.js").DataType|Record<string, import("./dtypes.js").DataType>} [dtype=null] The data type to use for the model. If not specified, the data type will be chosen from the environment settings.
  * @property {ExternalData|Record<string, ExternalData>} [use_external_data_format=false] Whether to load the model using the external data format (used for models >= 2GB in size).
@@ -160,7 +161,7 @@ export function buildResourcePaths(path_or_repo_id, filename, options = {}, cach
  * @param {import('./cache.js').CacheInterface | null} cache The cache instance to check.
  * @param {string} localPath The local path to try first.
  * @param {string} proposedCacheKey The proposed cache key to try second.
- * @returns {Promise<Response|import('./hub/files.js').FileResponse|undefined|string>}
+ * @returns {Promise<Response|import('./hub/FileResponse.js').FileResponse|undefined|string>}
  * The cached response if found, undefined otherwise.
  */
 export async function checkCachedResource(cache, localPath, proposedCacheKey) {
@@ -182,7 +183,7 @@ export async function checkCachedResource(cache, localPath, proposedCacheKey) {
  * @param {string} filename The name of the file to cache.
  * @param {import('./cache.js').CacheInterface} cache The cache instance to store in.
  * @param {string} cacheKey The cache key to use.
- * @param {Response|import('./hub/files.js').FileResponse} response The response to cache.
+ * @param {Response|import('./hub/FileResponse.js').FileResponse} response The response to cache.
  * @param {Uint8Array} [result] The result buffer if already read.
  * @param {PretrainedOptions} [options] Options containing progress callback and context for progress updates.
  * @returns {Promise<void>}
@@ -259,7 +260,7 @@ export async function loadResourceFile(
     // Whether to cache the final response in the end.
     let toCacheResponse = false;
 
-    /** @type {Response|import('./hub/files.js').FileResponse|undefined|string} */
+    /** @type {Response|import('./hub/FileResponse.js').FileResponse|undefined|string} */
     let response;
 
     // Check cache

package/src/utils/image.js

@@ -20,12 +20,11 @@ import { logger } from './logger.js';
 let createCanvasFunction;
 let ImageDataClass;
 let loadImageFunction;
-const IS_BROWSER_OR_WEBWORKER = apis.IS_BROWSER_ENV || apis.IS_WEBWORKER_ENV;
-if (IS_BROWSER_OR_WEBWORKER) {
+if (apis.IS_WEB_ENV) {
     // Running in browser or web-worker
     createCanvasFunction = (/** @type {number} */ width, /** @type {number} */ height) => {
         if (!self.OffscreenCanvas) {
-            throw new Error('OffscreenCanvas not supported by this browser.');
+            throw new Error('OffscreenCanvas not supported by this environment.');
         }
         return new self.OffscreenCanvas(width, height);
     };
@@ -134,7 +133,7 @@ export class RawImage {
      * @returns {RawImage} The image object.
      */
     static fromCanvas(canvas) {
-        if (!IS_BROWSER_OR_WEBWORKER) {
+        if (!apis.IS_WEB_ENV) {
             throw new Error('fromCanvas() is only supported in browser environments.');
         }
 
@@ -165,7 +164,7 @@ export class RawImage {
      * @returns {Promise<RawImage>} The image object.
      */
     static async fromBlob(blob) {
-        if (IS_BROWSER_OR_WEBWORKER) {
+        if (apis.IS_WEB_ENV) {
             // Running in environment with canvas
             const img = await loadImageFunction(blob);
 
@@ -379,7 +378,7 @@ export class RawImage {
             height = (width / this.width) * this.height;
         }
 
-        if (IS_BROWSER_OR_WEBWORKER) {
+        if (apis.IS_WEB_ENV) {
             // TODO use `resample` in browser environment
 
             // Store number of channels before resizing
@@ -453,7 +452,7 @@ export class RawImage {
             return this;
         }
 
-        if (IS_BROWSER_OR_WEBWORKER) {
+        if (apis.IS_WEB_ENV) {
             // Store number of channels before padding
             const numChannels = this.channels;
 
@@ -495,7 +494,7 @@ export class RawImage {
         const crop_width = x_max - x_min + 1;
         const crop_height = y_max - y_min + 1;
 
-        if (IS_BROWSER_OR_WEBWORKER) {
+        if (apis.IS_WEB_ENV) {
             // Store number of channels before resizing
             const numChannels = this.channels;
 
@@ -542,7 +541,7 @@ export class RawImage {
         const width_offset = (this.width - crop_width) / 2;
         const height_offset = (this.height - crop_height) / 2;
 
-        if (IS_BROWSER_OR_WEBWORKER) {
+        if (apis.IS_WEB_ENV) {
             // Store number of channels before resizing
             const numChannels = this.channels;
 
@@ -650,7 +649,7 @@ export class RawImage {
     }
 
     async toBlob(type = 'image/png', quality = 1) {
-        if (!IS_BROWSER_OR_WEBWORKER) {
+        if (!apis.IS_WEB_ENV) {
             throw new Error('toBlob() is only supported in browser environments.');
         }
 
@@ -673,7 +672,7 @@ export class RawImage {
     }
 
     toCanvas() {
-        if (!IS_BROWSER_OR_WEBWORKER) {
+        if (!apis.IS_WEB_ENV) {
             throw new Error('toCanvas() is only supported in browser environments.');
         }
 
@@ -774,7 +773,7 @@ export class RawImage {
      * @returns {Promise<void>}
      */
     async save(path) {
-        if (IS_BROWSER_OR_WEBWORKER) {
+        if (apis.IS_WEB_ENV) {
             if (apis.IS_WEBWORKER_ENV) {
                 throw new Error('Unable to save an image from a Web Worker.');
             }
@@ -799,7 +798,7 @@ export class RawImage {
      * @returns {import('sharp').Sharp} The Sharp instance.
      */
     toSharp() {
-        if (IS_BROWSER_OR_WEBWORKER) {
+        if (apis.IS_WEB_ENV) {
             throw new Error('toSharp() is only supported in server-side environments.');
         }
 

package/src/utils/lru_cache.js

@@ -0,0 +1,67 @@
+/**
+ * A simple Least Recently Used (LRU) cache implementation in JavaScript.
+ * This cache stores key-value pairs and evicts the least recently used item
+ * when the capacity is exceeded.
+ */
+export class LRUCache {
+    /** @type {number} */
+    #capacity;
+
+    /** @type {Map<any, any>} */
+    #cache;
+
+    /**
+     * Creates an LRUCache instance.
+     * @param {number} capacity The maximum number of items the cache can hold.
+     */
+    constructor(capacity) {
+        this.#capacity = capacity;
+        this.#cache = new Map();
+    }
+
+    /**
+     * Retrieves the value associated with the given key and marks the key as recently used.
+     * @param {any} key The key to retrieve.
+     * @returns {any} The value associated with the key, or undefined if the key does not exist.
+     */
+    get(key) {
+        if (!this.#cache.has(key)) return undefined;
+        const value = this.#cache.get(key);
+        this.#cache.delete(key);
+        this.#cache.set(key, value);
+        return value;
+    }
+
+    /**
+     * Inserts or updates the key-value pair in the cache.
+     * If the key already exists, it is updated and marked as recently used.
+     * If the cache exceeds its capacity, the least recently used item is evicted.
+     * @param {any} key The key to add or update.
+     * @param {any} value The value to associate with the key.
+     */
+    put(key, value) {
+        if (this.#cache.has(key)) {
+            this.#cache.delete(key);
+        }
+        this.#cache.set(key, value);
+        if (this.#cache.size > this.#capacity) {
+            this.#cache.delete(this.#cache.keys().next().value);
+        }
+    }
+
+    /**
+     * Removes the entry for the given key from the cache.
+     * @param {any} key The key to delete.
+     * @returns {boolean} `true` if the entry existed and was removed, `false` otherwise.
+     */
+    delete(key) {
+        return this.#cache.delete(key);
+    }
+
+    /**
+     * Clears the cache.
+     */
+    clear() {
+        this.#cache.clear();
+    }
+}

package/src/utils/memoize_promise.js

@@ -0,0 +1,45 @@
+/**
+ * @file Utility for memoizing promises by key.
+ *
+ * Ensures that a given async operation is only initiated once per key.
+ * Subsequent calls with the same key return the same pending or resolved promise.
+ * Rejected promises are evicted from the cache so callers can retry.
+ *
+ * The cache is bounded by `MAX_CACHE_SIZE`. When the limit is exceeded, the
+ * least-recently-used entry is evicted.
+ */
+
+import { LRUCache } from './lru_cache.js';
+
+const MAX_CACHE_SIZE = 100;
+
+/** @type {LRUCache} */
+const cache = new LRUCache(MAX_CACHE_SIZE);
+
+/**
+ * Returns the cached promise for `key`, or calls `factory` to create one and caches it.
+ * Subsequent calls with the same key return the same promise whether it is still
+ * pending or already resolved, so the factory is never invoked more than once per key.
+ * If the promise rejects, the entry is removed from the cache so the operation can be retried.
+ *
+ * @template T
+ * @param {string} key A unique identifier for this async operation.
+ * @param {() => Promise<T>} factory A function that returns the promise to memoize.
+ *   Only called when no entry exists for `key`.
+ * @returns {Promise<T>}
+ */
+export function memoizePromise(key, factory) {
+    const cached = cache.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const promise = factory().then(
+        (value) => value,
+        (err) => {
+            cache.delete(key);
+            return Promise.reject(err);
+        },
+    );
+    cache.put(key, promise);
+    return promise;
+}

package/src/utils/model_registry/ModelRegistry.js

@@ -49,8 +49,12 @@
  * const modelId = "onnx-community/Qwen3-0.6B-ONNX";
  * const options = { dtype: "q4" };
  *
- * // Check if the model is cached (probably false)
- * let cacheStatus = await ModelRegistry.is_cached(modelId, options);
+ * // Quickly check if the model is cached (probably false)
+ * let cached = await ModelRegistry.is_cached(modelId, options);
+ * console.log(cached); // false
+ *
+ * // Get per-file cache detail
+ * let cacheStatus = await ModelRegistry.is_cached_files(modelId, options);
  * console.log(cacheStatus);
  * // {
  * //   allCached: false,
@@ -66,12 +70,8 @@
  * console.log(output[0].generated_text.at(-1).content); // <think>...</think>\n\nThe capital of France is **Paris**.
  *
  * // Check if the model is cached (should be true now)
- * cacheStatus = await ModelRegistry.is_cached(modelId, options);
- * console.log(cacheStatus);
- * // {
- * //   allCached: true,
- * //   files: [ { file: 'config.json', cached: true }, { file: 'onnx/model_q4.onnx', cached: true }, { file: 'generation_config.json', cached: true }, { file: 'tokenizer.json', cached: true }, { file: 'tokenizer_config.json', cached: true } ]
- * // }
+ * cached = await ModelRegistry.is_cached(modelId, options);
+ * console.log(cached); // true
  *
  * // Clear the cache
  * const clearResult = await ModelRegistry.clear_cache(modelId, options);
@@ -83,12 +83,8 @@
  * // }
  *
  * // Check if the model is cached (should be false again)
- * cacheStatus = await ModelRegistry.is_cached(modelId, options);
- * console.log(cacheStatus);
- * // {
- * //   allCached: false,
- * //   files: [ { file: 'config.json', cached: true }, { file: 'onnx/model_q4.onnx', cached: false }, { file: 'generation_config.json', cached: false }, { file: 'tokenizer.json', cached: false }, { file: 'tokenizer_config.json', cached: false } ]
- * // }
+ * cached = await ModelRegistry.is_cached(modelId, options);
+ * console.log(cached); // false
  * ```
  *
  * @module utils/model_registry
@@ -99,7 +95,7 @@ import { get_pipeline_files } from './get_pipeline_files.js';
 import { get_model_files } from './get_model_files.js';
 import { get_tokenizer_files } from './get_tokenizer_files.js';
 import { get_processor_files } from './get_processor_files.js';
-import { is_cached, is_pipeline_cached } from './is_cached.js';
+import { is_cached, is_cached_files, is_pipeline_cached, is_pipeline_cached_files } from './is_cached.js';
 import { get_file_metadata } from './get_file_metadata.js';
 import { clear_cache, clear_pipeline_cache } from './clear_cache.js';
 
@@ -198,27 +194,31 @@ export class ModelRegistry {
     }
 
     /**
-     * Check if a model and all its required files are cached.
+     * Quickly checks if a model is fully cached by verifying `config.json` is present,
+     * then confirming all required files are cached.
+     * Returns a plain boolean — use `is_cached_files` if you need per-file detail.
      *
      * @param {string} modelId - The model id
      * @param {Object} [options] - Optional parameters
+     * @param {string} [options.cache_dir] - Custom cache directory
+     * @param {string} [options.revision] - Model revision (default: 'main')
+     * @param {import('../../configs.js').PretrainedConfig} [options.config] - Pre-loaded config
      * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype=null] - Override dtype
      * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device=null] - Override device
-     * @returns {Promise<import('./is_cached.js').CacheCheckResult>} Object with allCached boolean and files array with cache status
+     * @returns {Promise<boolean>} Whether all required files are cached
      *
      * @example
-     * const status = await ModelRegistry.is_cached('onnx-community/bert-base-uncased-ONNX');
-     * console.log(status.allCached); // true or false
+     * const cached = await ModelRegistry.is_cached('onnx-community/bert-base-uncased-ONNX');
+     * console.log(cached); // true or false
      */
     static async is_cached(modelId, options = {}) {
         return is_cached(modelId, options);
     }
 
     /**
-     * Check if all files for a specific pipeline task are cached.
-     * Automatically determines which components are needed based on the task.
+     * Checks if all files for a given model are already cached, with per-file detail.
+     * Automatically determines which files are needed using get_files().
      *
-     * @param {string} task - The pipeline task (e.g., "text-generation", "background-removal")
      * @param {string} modelId - The model id
      * @param {Object} [options] - Optional parameters
      * @param {string} [options.cache_dir] - Custom cache directory
@@ -229,13 +229,60 @@ export class ModelRegistry {
      * @returns {Promise<import('./is_cached.js').CacheCheckResult>} Object with allCached boolean and files array with cache status
      *
      * @example
-     * const status = await ModelRegistry.is_pipeline_cached('text-generation', 'onnx-community/gpt2-ONNX');
+     * const status = await ModelRegistry.is_cached_files('onnx-community/bert-base-uncased-ONNX');
      * console.log(status.allCached); // true or false
+     * console.log(status.files); // [{ file: 'config.json', cached: true }, ...]
+     */
+    static async is_cached_files(modelId, options = {}) {
+        return is_cached_files(modelId, options);
+    }
+
+    /**
+     * Quickly checks if all files for a specific pipeline task are cached by verifying
+     * `config.json` is present, then confirming all required files are cached.
+     * Returns a plain boolean — use `is_pipeline_cached_files` if you need per-file detail.
+     *
+     * @param {string} task - The pipeline task (e.g., "text-generation", "background-removal")
+     * @param {string} modelId - The model id
+     * @param {Object} [options] - Optional parameters
+     * @param {string} [options.cache_dir] - Custom cache directory
+     * @param {string} [options.revision] - Model revision (default: 'main')
+     * @param {import('../../configs.js').PretrainedConfig} [options.config] - Pre-loaded config
+     * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype=null] - Override dtype
+     * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device=null] - Override device
+     * @returns {Promise<boolean>} Whether all required files are cached
+     *
+     * @example
+     * const cached = await ModelRegistry.is_pipeline_cached('text-generation', 'onnx-community/gpt2-ONNX');
+     * console.log(cached); // true or false
      */
     static async is_pipeline_cached(task, modelId, options = {}) {
         return is_pipeline_cached(task, modelId, options);
     }
 
+    /**
+     * Checks if all files for a specific pipeline task are already cached, with per-file detail.
+     * Automatically determines which components are needed based on the task.
+     *
+     * @param {string} task - The pipeline task (e.g., "text-generation", "background-removal")
+     * @param {string} modelId - The model id
+     * @param {Object} [options] - Optional parameters
+     * @param {string} [options.cache_dir] - Custom cache directory
+     * @param {string} [options.revision] - Model revision (default: 'main')
+     * @param {import('../../configs.js').PretrainedConfig} [options.config] - Pre-loaded config
+     * @param {import('../dtypes.js').DataType|Record<string, import('../dtypes.js').DataType>} [options.dtype=null] - Override dtype
+     * @param {import('../devices.js').DeviceType|Record<string, import('../devices.js').DeviceType>} [options.device=null] - Override device
+     * @returns {Promise<import('./is_cached.js').CacheCheckResult>} Object with allCached boolean and files array with cache status
+     *
+     * @example
+     * const status = await ModelRegistry.is_pipeline_cached_files('text-generation', 'onnx-community/gpt2-ONNX');
+     * console.log(status.allCached); // true or false
+     * console.log(status.files); // [{ file: 'config.json', cached: true }, ...]
+     */
+    static async is_pipeline_cached_files(task, modelId, options = {}) {
+        return is_pipeline_cached_files(task, modelId, options);
+    }
+
     /**
      * Get metadata for a specific file without downloading it.
      *

package/src/utils/model_registry/get_file_metadata.js

@@ -7,6 +7,7 @@ import { getCache } from '../cache.js';
 import { buildResourcePaths, checkCachedResource, getFetchHeaders, getFile } from '../hub.js';
 import { isValidUrl } from '../hub/utils.js';
 import { logger } from '../logger.js';
+import { memoizePromise } from '../memoize_promise.js';
 
 /**
  * @typedef {import('../hub.js').PretrainedOptions} PretrainedOptions
@@ -34,7 +35,7 @@ async function fetch_file_head(urlOrPath) {
 
     const headers = getFetchHeaders(urlOrPath);
     headers.set('Range', 'bytes=0-0');
-    return env.fetch(urlOrPath, { method: 'GET', headers });
+    return env.fetch(urlOrPath, { method: 'GET', headers, cache: 'no-store' });
 }
 
 /**
@@ -49,7 +50,18 @@ async function fetch_file_head(urlOrPath) {
  * @param {PretrainedOptions} [options] An object containing optional parameters.
  * @returns {Promise<{exists: boolean, size?: number, contentType?: string, fromCache?: boolean}>} A Promise that resolves to file metadata.
  */
-export async function get_file_metadata(path_or_repo_id, filename, options = {}) {
+export function get_file_metadata(path_or_repo_id, filename, options = {}) {
+    const key = JSON.stringify([
+        path_or_repo_id,
+        filename,
+        options?.revision,
+        options?.cache_dir,
+        options?.local_files_only,
+    ]);
+    return memoizePromise(key, () => _get_file_metadata(path_or_repo_id, filename, options));
+}
+
+async function _get_file_metadata(path_or_repo_id, filename, options) {
     /** @type {import('../cache.js').CacheInterface | null} */
     const cache = await getCache(options?.cache_dir);
     const { localPath, remoteURL, proposedCacheKey, validModelId } = buildResourcePaths(