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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huggingface/transformers",
-  "version": "4.0.0-next.4",
+  "version": "4.0.0-next.5",
   "description": "State-of-the-art Machine Learning for the web. Run 🤗 Transformers directly in your browser, with no need for a server!",
   "main": "./dist/transformers.node.cjs",
   "types": "./types/transformers.d.ts",
@@ -44,9 +44,9 @@
   "homepage": "https://github.com/huggingface/transformers.js#readme",
   "dependencies": {
     "@huggingface/jinja": "^0.5.5",
-    "@huggingface/tokenizers": "^0.1.1",
-    "onnxruntime-node": "1.24.1",
-    "onnxruntime-web": "1.25.0-dev.20260212-1a71a5f46e",
+    "@huggingface/tokenizers": "^0.1.2",
+    "onnxruntime-node": "1.24.2",
+    "onnxruntime-web": "1.25.0-dev.20260228-6e72d31970",
     "sharp": "^0.34.5"
   },
   "devDependencies": {

package/src/backends/onnx.js

@@ -16,13 +16,14 @@
  * @module backends/onnx
  */
 
-import { env, apis } from '../env.js';
+import { env, apis, LogLevel } from '../env.js';
 
 // NOTE: Import order matters here. We need to import `onnxruntime-node` before `onnxruntime-web`.
 // In either case, we select the default export if it exists, otherwise we use the named export.
 import * as ONNX_NODE from 'onnxruntime-node';
 import * as ONNX_WEB from 'onnxruntime-web/webgpu';
 import { isBlobURL, loadWasmBinary, loadWasmFactory, toAbsoluteURL } from './utils/cacheWasm.js';
+import { logger } from '../utils/logger.js';
 export { Tensor } from 'onnxruntime-common';
 
 /**
@@ -46,9 +47,48 @@ const DEVICE_TO_EXECUTION_PROVIDER_MAPPING = Object.freeze({
     'webnn-cpu': { name: 'webnn', deviceType: 'cpu' }, // WebNN CPU
 });
 
-/** @type {Array<'verbose' | 'info' | 'warning' | 'error' | 'fatal'>} */
-const LOG_LEVELS = ['verbose', 'info', 'warning', 'error', 'fatal'];
-const DEFAULT_LOG_LEVEL = 4; // 'fatal';
+/**
+ * Converts any LogLevel value to ONNX Runtime's numeric severity level (0-4).
+ * This handles both standard LogLevel values (10, 20, 30, 40, 50) and custom intermediate values.
+ *
+ * @param {number} logLevel - The LogLevel value to convert
+ * @returns {number} ONNX Runtime severity level (0-4)
+ */
+function getOnnxLogSeverityLevel(logLevel) {
+    // ONNX Runtime's log severity levels are defined as follows:
+    // (0) ORT_LOGGING_LEVEL_VERBOSE: Print all log messages.
+    // (1) ORT_LOGGING_LEVEL_INFO: Print info and higher level log messages.
+    // (2) ORT_LOGGING_LEVEL_WARNING: Print warning and higher level log messages.
+    // (3) ORT_LOGGING_LEVEL_ERROR: Print error log messages.
+    // (4) ORT_LOGGING_LEVEL_FATAL: Print only fatal log messages.
+    //
+    // In practice, ONNX Runtime's logging is extremely verbose (especially on session creation).
+    // For this reason, we map multiple LogLevel values to the same ONNX severity level to avoid
+    // overwhelming users with logs.
+    if (logLevel <= LogLevel.DEBUG) {
+        return 0; // ORT_LOGGING_LEVEL_VERBOSE
+    } else if (logLevel <= LogLevel.INFO) {
+        return 2; // ORT_LOGGING_LEVEL_WARNING
+    } else if (logLevel <= LogLevel.WARNING) {
+        return 3; // ORT_LOGGING_LEVEL_ERROR
+    } else if (logLevel <= LogLevel.ERROR) {
+        return 3; // ORT_LOGGING_LEVEL_ERROR
+    } else {
+        return 4; // ORT_LOGGING_LEVEL_FATAL
+    }
+}
+
+/**
+ * Maps ONNX Runtime numeric severity levels to string log levels.
+ * @type {Record<0 | 1 | 2 | 3 | 4, 'verbose' | 'info' | 'warning' | 'error' | 'fatal'>}
+ */
+const ONNX_LOG_LEVEL_NAMES = {
+    0: 'verbose',
+    1: 'info',
+    2: 'warning',
+    3: 'error',
+    4: 'fatal',
+};
 
 /**
  * The list of supported devices, sorted by priority/performance.
@@ -193,7 +233,7 @@ async function ensureWasmLoaded() {
                               ONNX_ENV.wasm.wasmBinary = wasmBinary;
                           }
                       } catch (err) {
-                          console.warn('Failed to pre-load WASM binary:', err);
+                          logger.warn('Failed to pre-load WASM binary:', err);
                       }
                   })()
                 : Promise.resolve(),
@@ -208,7 +248,7 @@ async function ensureWasmLoaded() {
                               ONNX_ENV.wasm.wasmPaths.mjs = wasmFactoryBlob;
                           }
                       } catch (err) {
-                          console.warn('Failed to pre-load WASM factory:', err);
+                          logger.warn('Failed to pre-load WASM factory:', err);
                       }
                   })()
                 : Promise.resolve(),
@@ -227,10 +267,11 @@ async function ensureWasmLoaded() {
  */
 export async function createInferenceSession(buffer_or_path, session_options, session_config) {
     await ensureWasmLoaded();
+    const logSeverityLevel = getOnnxLogSeverityLevel(env.logLevel ?? LogLevel.WARNING);
     const load = () =>
         InferenceSession.create(buffer_or_path, {
-            // Set default log level, but allow overriding through session options
-            logSeverityLevel: DEFAULT_LOG_LEVEL,
+            // Set default log severity level, but allow overriding through session options
+            logSeverityLevel,
             ...session_options,
         });
     const session = await (IS_WEB_ENV ? (webInitChain = webInitChain.then(load)) : load());
@@ -268,7 +309,6 @@ export function isONNXTensor(x) {
 
 /** @type {import('onnxruntime-common').Env} */
 const ONNX_ENV = ONNX?.env;
-ONNX_ENV.logLevel = LOG_LEVELS[DEFAULT_LOG_LEVEL];
 if (ONNX_ENV?.wasm) {
     // Initialize wasm backend with suitable default settings.
 
@@ -311,5 +351,21 @@ export function isONNXProxy() {
     return ONNX_ENV?.wasm?.proxy;
 }
 
+/**
+ * A function to map Transformers.js log levels to ONNX Runtime log severity
+ * levels, and set the log level environment variable in ONNX Runtime.
+ * @param {number} logLevel The log level to set.
+ */
+function setLogLevel(logLevel) {
+    const severityLevel = getOnnxLogSeverityLevel(logLevel);
+    ONNX_ENV.logLevel = ONNX_LOG_LEVEL_NAMES[severityLevel];
+}
+
+// Set the initial log level to be the default Transformers.js log level.
+setLogLevel(env.logLevel ?? LogLevel.WARNING);
+
 // Expose ONNX environment variables to `env.backends.onnx`
-env.backends.onnx = ONNX_ENV;
+env.backends.onnx = {
+    ...ONNX_ENV,
+    setLogLevel,
+};

package/src/backends/utils/cacheWasm.js

@@ -1,5 +1,7 @@
 import { getCache } from '../../utils/cache.js';
 import { isValidUrl } from '../../utils/hub/utils.js';
+import { logger } from '../../utils/logger.js';
+import { env } from '../../env.js';
 
 /**
  * Loads and caches a file from the given URL.
@@ -22,11 +24,11 @@ async function loadAndCacheFile(url) {
             }
         }
     } catch (error) {
-        console.warn(`Failed to load ${fileName} from cache:`, error);
+        logger.warn(`Failed to load ${fileName} from cache:`, error);
     }
 
     // If not in cache, fetch it
-    const response = await fetch(url);
+    const response = await env.fetch(url);
 
     if (!response.ok) {
         throw new Error(`Failed to fetch ${fileName}: ${response.status} ${response.statusText}`);
@@ -37,7 +39,7 @@ async function loadAndCacheFile(url) {
         try {
             await cache.put(url, response.clone());
         } catch (e) {
-            console.warn(`Failed to cache ${fileName}:`, e);
+            logger.warn(`Failed to cache ${fileName}:`, e);
         }
     }
 
@@ -57,7 +59,7 @@ export async function loadWasmBinary(wasmURL) {
     try {
         return await response.arrayBuffer();
     } catch (error) {
-        console.warn('Failed to read WASM binary:', error);
+        logger.warn('Failed to read WASM binary:', error);
         return null;
     }
 }
@@ -75,11 +77,12 @@ export async function loadWasmFactory(libURL) {
         let code = await response.text();
         // Fix relative paths when loading factory from blob, overwrite import.meta.url with actual baseURL
         const baseUrl = libURL.split('/').slice(0, -1).join('/');
-        code = code.replace(/import\.meta\.url/g, `"${baseUrl}"`);
+        code = code.replaceAll('import.meta.url', `"${baseUrl}"`);
+        code = code.replaceAll('globalThis.process?.versions?.node', 'false');
         const blob = new Blob([code], { type: 'text/javascript' });
         return URL.createObjectURL(blob);
     } catch (error) {
-        console.warn('Failed to read WASM binary:', error);
+        logger.warn('Failed to read WASM binary:', error);
         return null;
     }
 }

package/src/configs.js

@@ -74,6 +74,8 @@ function getNormalizedConfig(config) {
         case 'gemma3n':
         case 'chatterbox':
         case 'mistral3':
+        case 'qwen2_5_vl':
+        case 'qwen3_vl':
             // @ts-expect-error TS2339
             init_normalized_config = getNormalizedConfig(config.text_config);
             break;
@@ -115,6 +117,7 @@ function getNormalizedConfig(config) {
         case 'nanochat':
         case 'apertus':
         case 'arcee':
+        case 'afmoe':
         case 'lfm2':
         case 'lfm2_moe':
         case 'smollm3':
@@ -130,6 +133,8 @@ function getNormalizedConfig(config) {
         case 'starcoder2':
         case 'qwen2':
         case 'qwen2_vl':
+        case 'qwen2_5_vl_text':
+        case 'qwen3_vl_text':
         case 'phi':
         case 'phi3':
         case 'phi3_v':
@@ -288,11 +293,10 @@ export function getCacheShapes(config, options) {
         const pkv_prefix = options?.prefix ?? 'past_key_values';
         const conv_prefix = pkv_prefix === 'present' ? 'present' : 'past';
 
-        // Custom caching mechanism for LFM2
         /** @type {Record<string, number[]>} */
         const cache_values = {};
-        // @ts-expect-error TS2339
-        const { layer_types, num_attention_heads, num_key_value_heads, hidden_size, conv_L_cache } = config;
+        const { layer_types, num_attention_heads, num_key_value_heads, hidden_size, conv_L_cache } =
+            /** @type {any} */ (config);
         const head_dim = hidden_size / num_attention_heads;
         const batch_size = options?.batch_size ?? 1;
         for (let i = 0; i < layer_types.length; ++i) {
@@ -344,6 +348,50 @@ export function getCacheShapes(config, options) {
             }
         }
         return cache_values;
+    } else if (['qwen3_5', 'qwen3_5_moe'].includes(config.model_type)) {
+        const pkv_prefix = options?.prefix ?? 'past_key_values';
+        const conv_prefix = pkv_prefix === 'present' ? 'present' : 'past';
+
+        /** @type {Record<string, number[]>} */
+        const cache_values = {};
+        const {
+            head_dim,
+            layer_types,
+            num_attention_heads,
+            num_key_value_heads,
+            hidden_size,
+            linear_num_value_heads,
+            linear_num_key_heads,
+            linear_key_head_dim,
+            linear_value_head_dim,
+            linear_conv_kernel_dim,
+        } = /** @type {any} */ (config).text_config;
+
+        const key_dim = linear_key_head_dim * linear_num_key_heads;
+        const value_dim = linear_value_head_dim * linear_num_value_heads;
+
+        const conv_dim = key_dim * 2 + value_dim;
+
+        const final_head_dim = head_dim ?? hidden_size / num_attention_heads;
+        const batch_size = options?.batch_size ?? 1;
+        for (let i = 0; i < layer_types.length; ++i) {
+            if (layer_types[i] === 'full_attention') {
+                for (const kv of ['key', 'value']) {
+                    cache_values[`${pkv_prefix}.${i}.${kv}`] = [batch_size, num_key_value_heads, 0, final_head_dim];
+                }
+            } else if (layer_types[i] === 'linear_attention') {
+                cache_values[`${conv_prefix}_conv.${i}`] = [batch_size, conv_dim, linear_conv_kernel_dim];
+                cache_values[`${conv_prefix}_recurrent.${i}`] = [
+                    batch_size,
+                    linear_num_value_heads,
+                    linear_key_head_dim,
+                    linear_value_head_dim,
+                ];
+            } else {
+                throw new Error(`Unsupported layer type: ${layer_types[i]}`);
+            }
+        }
+        return cache_values;
     }
     return getKeyValueShapes(config, options);
 }

package/src/env.js

@@ -26,17 +26,21 @@ import fs from 'node:fs';
 import path from 'node:path';
 import url from 'node:url';
 
-const VERSION = '4.0.0-next.4';
+const VERSION = '4.0.0-next.5';
 
-const IS_PROCESS_AVAILABLE = typeof process !== 'undefined';
-const IS_NODE_ENV = IS_PROCESS_AVAILABLE && process?.release?.name === 'node';
 const IS_FS_AVAILABLE = !isEmpty(fs);
 const IS_PATH_AVAILABLE = !isEmpty(path);
+const IS_WEB_CACHE_AVAILABLE = typeof self !== 'undefined' && 'caches' in self;
 
 // Runtime detection
 const IS_DENO_RUNTIME = typeof globalThis.Deno !== 'undefined';
 const IS_BUN_RUNTIME = typeof globalThis.Bun !== 'undefined';
 
+const IS_DENO_WEB_RUNTIME = IS_DENO_RUNTIME && IS_WEB_CACHE_AVAILABLE && !IS_FS_AVAILABLE;
+
+const IS_PROCESS_AVAILABLE = typeof process !== 'undefined';
+const IS_NODE_ENV = IS_PROCESS_AVAILABLE && process?.release?.name === 'node' && !IS_DENO_WEB_RUNTIME;
+
 // Check if various APIs are available (depends on environment)
 const IS_BROWSER_ENV = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 const IS_WEBWORKER_ENV =
@@ -44,9 +48,9 @@ const IS_WEBWORKER_ENV =
     ['DedicatedWorkerGlobalScope', 'ServiceWorkerGlobalScope', 'SharedWorkerGlobalScope'].includes(
         self.constructor?.name,
     );
-const IS_WEB_CACHE_AVAILABLE = typeof self !== 'undefined' && 'caches' in self;
 const IS_WEBGPU_AVAILABLE = IS_NODE_ENV || (typeof navigator !== 'undefined' && 'gpu' in navigator);
 const IS_WEBNN_AVAILABLE = typeof navigator !== 'undefined' && 'ml' in navigator;
+const IS_CRYPTO_AVAILABLE = typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function';
 
 /**
  * Check if the current environment is Safari browser.
@@ -109,6 +113,9 @@ export const apis = Object.freeze({
 
     /** Whether the path API is available */
     IS_PATH_AVAILABLE,
+
+    /** Whether the crypto API is available */
+    IS_CRYPTO_AVAILABLE,
 });
 
 const RUNNING_LOCALLY = IS_FS_AVAILABLE && IS_PATH_AVAILABLE;
@@ -134,12 +141,48 @@ const DEFAULT_CACHE_DIR = RUNNING_LOCALLY ? path.join(dirname__, '/.cache/') : n
 const DEFAULT_LOCAL_MODEL_PATH = '/models/';
 const localModelPath = RUNNING_LOCALLY ? path.join(dirname__, DEFAULT_LOCAL_MODEL_PATH) : DEFAULT_LOCAL_MODEL_PATH;
 
+// Ensure default fetch is called with the correct receiver in browser environments.
+const DEFAULT_FETCH = typeof globalThis.fetch === 'function' ? globalThis.fetch.bind(globalThis) : undefined;
+
+/**
+ * Log levels for controlling output verbosity.
+ *
+ * Each level is represented by a number, where higher numbers include all lower level messages.
+ * Use these values to set `env.logLevel`.
+ *
+ * @example
+ * import { env, LogLevel } from '@huggingface/transformers';
+ *
+ * // Set log level to show only errors
+ * env.logLevel = LogLevel.ERROR;
+ *
+ * // Set log level to show errors, warnings, and info
+ * env.logLevel = LogLevel.INFO;
+ *
+ * // Disable all logging
+ * env.logLevel = LogLevel.NONE;
+ *
+ */
+export const LogLevel = Object.freeze({
+    /** All messages including debug output (value: 10) */
+    DEBUG: 10,
+    /** Errors, warnings, and info messages (value: 20) */
+    INFO: 20,
+    /** Errors and warnings (value: 30) */
+    WARNING: 30,
+    /** Only error messages (value: 40) */
+    ERROR: 40,
+    /** No logging output (value: 50) */
+    NONE: 50,
+});
+
 /**
  * Global variable given visible to users to control execution. This provides users a simple way to configure Transformers.js.
  * @typedef {Object} TransformersEnvironment
  * @property {string} version This version of Transformers.js.
- * @property {{onnx: Partial<import('onnxruntime-common').Env>}} backends Expose environment variables of different backends,
+ * @property {{onnx: Partial<import('onnxruntime-common').Env> & { setLogLevel?: (logLevel: number) => void }}} backends Expose environment variables of different backends,
  * allowing users to set these variables if they want to.
+ * @property {number} logLevel The logging level. Use LogLevel enum values. Defaults to LogLevel.ERROR.
  * @property {boolean} allowRemoteModels Whether to allow loading of remote files, defaults to `true`.
  * If set to `false`, it will have the same effect as setting `local_files_only=true` when loading pipelines, models, tokenizers, processors, etc.
  * @property {string} remoteHost Host URL to load models from. Defaults to the Hugging Face Hub.
@@ -158,8 +201,10 @@ const localModelPath = RUNNING_LOCALLY ? path.join(dirname__, DEFAULT_LOCAL_MODE
  * This can improve performance by avoiding repeated downloads of WASM files. Note: Only the WASM binary is cached.
  * The MJS loader file still requires network access unless you use a Service Worker.
  * @property {string} cacheKey The cache key to use for storing models and WASM binaries. Defaults to 'transformers-cache'.
+ * @property {(input: string | URL, init?: any) => Promise<any>} fetch The fetch function to use. Defaults to `fetch`.
  */
 
+let logLevel = LogLevel.WARNING; // Default log level
 /** @type {TransformersEnvironment} */
 export const env = {
     version: VERSION,
@@ -171,17 +216,27 @@ export const env = {
         onnx: {},
     },
 
+    /////////////////// Logging settings ///////////////////
+    get logLevel() {
+        return logLevel;
+    },
+    set logLevel(level) {
+        logLevel = level;
+
+        // invoke hook to set ONNX Runtime log level when Transformers.js log level changes
+        env.backends.onnx?.setLogLevel?.(level);
+    },
     /////////////////// Model settings ///////////////////
     allowRemoteModels: true,
     remoteHost: 'https://huggingface.co/',
     remotePathTemplate: '{model}/resolve/{revision}/',
 
-    allowLocalModels: !(IS_BROWSER_ENV || IS_WEBWORKER_ENV),
+    allowLocalModels: !(IS_BROWSER_ENV || IS_WEBWORKER_ENV || IS_DENO_WEB_RUNTIME), // Default to true for non-web environments, false for web environments
     localModelPath: localModelPath,
     useFS: IS_FS_AVAILABLE,
 
     /////////////////// Cache settings ///////////////////
-    useBrowserCache: IS_WEB_CACHE_AVAILABLE && !IS_DENO_RUNTIME,
+    useBrowserCache: IS_WEB_CACHE_AVAILABLE,
 
     useFSCache: IS_FS_AVAILABLE,
     cacheDir: DEFAULT_CACHE_DIR,
@@ -191,6 +246,10 @@ export const env = {
 
     useWasmCache: IS_WEB_CACHE_AVAILABLE || IS_FS_AVAILABLE,
     cacheKey: 'transformers-cache',
+
+    /////////////////// Custom fetch /////////////////////
+    fetch: DEFAULT_FETCH,
+
     //////////////////////////////////////////////////////
 };
 

package/src/generation/logits_sampler.js

@@ -6,6 +6,7 @@ import { Callable } from '../utils/generic.js';
 import { Tensor, topk } from '../utils/tensor.js';
 
 import { max, softmax } from '../utils/maths.js';
+import { _weightedIndex } from '../utils/random.js';
 import { GenerationConfig } from '../generation/configuration_utils.js';
 
 /**
@@ -64,24 +65,11 @@ export class LogitsSampler extends Callable {
 
     /**
      * Selects an item randomly based on the specified probabilities.
-     * @param {import("../transformers.js").DataArray} probabilities An array of probabilities to use for selection.
+     * @param {Float32Array} probabilities An array of probabilities to use for selection.
      * @returns {number} The index of the selected item.
      */
     randomSelect(probabilities) {
-        // Return index of chosen item
-        let sumProbabilities = 0;
-        for (let i = 0; i < probabilities.length; ++i) {
-            sumProbabilities += probabilities[i];
-        }
-
-        let r = Math.random() * sumProbabilities;
-        for (let i = 0; i < probabilities.length; ++i) {
-            r -= probabilities[i];
-            if (r <= 0) {
-                return i;
-            }
-        }
-        return 0; // return first (most probable) as a fallback
+        return _weightedIndex(probabilities);
     }
 
     /**

package/src/image_processors_utils.js

@@ -5,6 +5,7 @@ import { RawImage } from './utils/image.js';
 import { calculateReflectOffset } from './utils/core.js';
 import { getModelJSON } from './utils/hub.js';
 import { IMAGE_PROCESSOR_NAME } from './utils/constants.js';
+import { logger } from './utils/logger.js';
 
 /**
  * Named tuple to indicate the order we are using is (height x width),
@@ -450,7 +451,7 @@ export function post_process_panoptic_segmentation(
     target_sizes = null,
 ) {
     if (label_ids_to_fuse === null) {
-        console.warn('`label_ids_to_fuse` unset. No instance will be fused.');
+        logger.warn('`label_ids_to_fuse` unset. No instance will be fused.');
         label_ids_to_fuse = new Set();
     }
 
@@ -864,11 +865,6 @@ export class ImageProcessor extends Callable {
             return [newWidth, newHeight];
         } else if (this.size_divisibility !== undefined) {
             return enforce_size_divisibility([srcWidth, srcHeight], this.size_divisibility);
-        } else if (this.min_pixels !== undefined && this.max_pixels !== undefined) {
-            // Custom resize logic for Qwen2-VL models
-            // @ts-expect-error TS2339
-            const factor = this.config.patch_size * this.config.merge_size;
-            return smart_resize(srcHeight, srcWidth, factor, this.min_pixels, this.max_pixels);
         } else {
             throw new Error(
                 `Could not resize image due to unsupported \`this.size\` option in config: ${JSON.stringify(size)}`,

package/src/models/afmoe/modeling_afmoe.js

@@ -0,0 +1,5 @@
+import { PreTrainedModel } from '../modeling_utils.js';
+
+export class AfmoePreTrainedModel extends PreTrainedModel {}
+export class AfmoeModel extends AfmoePreTrainedModel {}
+export class AfmoeForCausalLM extends AfmoePreTrainedModel {}

package/src/models/auto/image_processing_auto.js

@@ -2,6 +2,7 @@ import { getModelJSON } from '../../utils/hub.js';
 import { ImageProcessor } from '../../image_processors_utils.js';
 import * as AllImageProcessors from '../image_processors.js';
 import { GITHUB_ISSUE_URL, IMAGE_PROCESSOR_NAME } from '../../utils/constants.js';
+import { logger } from '../../utils/logger.js';
 
 export class AutoImageProcessor {
     /** @type {typeof ImageProcessor.from_pretrained} */
@@ -20,7 +21,7 @@ export class AutoImageProcessor {
         if (!image_processor_class) {
             if (key !== undefined) {
                 // Only log a warning if the class is not found and the key is set.
-                console.warn(
+                logger.warn(
                     `Image processor type '${key}' not found, assuming base ImageProcessor. Please report this at ${GITHUB_ISSUE_URL}.`,
                 );
             }

package/src/models/auto/modeling_auto.js

@@ -43,6 +43,7 @@ import { PreTrainedModel } from '../modeling_utils.js';
 import { CUSTOM_ARCHITECTURES, MODEL_CLASS_TYPE_MAPPING, MODEL_MAPPINGS } from '../registry.js';
 
 import * as ALL_MODEL_FILES from '../models.js';
+import { logger } from '../../utils/logger.js';
 
 /**
  * Base class of all AutoModels. Contains the `from_pretrained` function
@@ -114,7 +115,7 @@ class PretrainedMixin {
 
         if (this.BASE_IF_FAIL) {
             if (!CUSTOM_ARCHITECTURES.has(model_type)) {
-                console.warn(`Unknown model class "${model_type}", attempting to construct from base class.`);
+                logger.warn(`Unknown model class "${model_type}", attempting to construct from base class.`);
             }
             return await PreTrainedModel.from_pretrained(pretrained_model_name_or_path, options);
         } else {

package/src/models/auto/tokenization_auto.js

@@ -1,5 +1,6 @@
 import { PreTrainedTokenizer, loadTokenizer } from '../../tokenization_utils.js';
 import * as AllTokenizers from '../tokenizers.js';
+import { logger } from '../../utils/logger.js';
 
 /**
  * Helper class which is used to instantiate pretrained tokenizers with the `from_pretrained` function.
@@ -54,7 +55,7 @@ export class AutoTokenizer {
 
         let cls = AllTokenizers[tokenizerName];
         if (!cls) {
-            console.warn(`Unknown tokenizer class "${tokenizerName}", attempting to construct from base class.`);
+            logger.warn(`Unknown tokenizer class "${tokenizerName}", attempting to construct from base class.`);
             cls = PreTrainedTokenizer;
         }
         return new cls(tokenizerJSON, tokenizerConfig);

package/src/models/clap/feature_extraction_clap.js

@@ -1,6 +1,7 @@
 import { FeatureExtractor, validate_audio_inputs } from '../../feature_extraction_utils.js';
 import { Tensor } from '../../utils/tensor.js';
 import { mel_filter_bank, spectrogram, window_function } from '../../utils/audio.js';
+import { random } from '../../utils/random.js';
 
 export class ClapFeatureExtractor extends FeatureExtractor {
     constructor(config) {
@@ -58,7 +59,7 @@ export class ClapFeatureExtractor extends FeatureExtractor {
         if (diff > 0) {
             if (truncation === 'rand_trunc') {
                 longer = true;
-                const idx = Math.floor(Math.random() * (diff + 1));
+                const idx = Math.floor(random.random() * (diff + 1));
                 waveform = waveform.subarray(idx, idx + max_length);
 
                 input_mel = await this._extract_fbank_features(

package/src/models/marian/tokenization_marian.js

@@ -1,5 +1,6 @@
 import { PreTrainedTokenizer } from '../../tokenization_utils.js';
 import { mergeArrays } from '../../utils/core.js';
+import { logger } from '../../utils/logger.js';
 
 /**
  * @todo This model is not yet supported by Hugging Face's "fast" tokenizers library (https://github.com/huggingface/tokenizers).
@@ -18,7 +19,7 @@ export class MarianTokenizer extends PreTrainedTokenizer {
 
         this.supported_language_codes = Array.from(this.get_vocab().keys()).filter((x) => this.languageRegex.test(x));
 
-        console.warn(
+        logger.warn(
             'WARNING: `MarianTokenizer` is not yet supported by Hugging Face\'s "fast" tokenizers library. Therefore, you may experience slightly inaccurate results.',
         );
     }
@@ -45,7 +46,7 @@ export class MarianTokenizer extends PreTrainedTokenizer {
             const [language, text] = remainder;
 
             if (!this.supported_language_codes.includes(language)) {
-                console.warn(
+                logger.warn(
                     `Unsupported language code "${language}" detected, which may lead to unexpected behavior. Should be one of: ${JSON.stringify(this.supported_language_codes)}`,
                 );
             }