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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huggingface/transformers",
-  "version": "4.0.0-next.5",
+  "version": "4.0.0-next.6",
   "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",
@@ -45,8 +45,8 @@
   "dependencies": {
     "@huggingface/jinja": "^0.5.5",
     "@huggingface/tokenizers": "^0.1.2",
-    "onnxruntime-node": "1.24.2",
-    "onnxruntime-web": "1.25.0-dev.20260228-6e72d31970",
+    "onnxruntime-node": "1.24.3",
+    "onnxruntime-web": "1.25.0-dev.20260303-e7e64dc112",
     "sharp": "^0.34.5"
   },
   "devDependencies": {

package/src/backends/onnx.js

@@ -22,7 +22,8 @@ import { env, apis, LogLevel } from '../env.js';
 // 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 { loadWasmBinary, loadWasmFactory } from './utils/cacheWasm.js';
+import { isBlobURL, toAbsoluteURL } from '../utils/hub/utils.js';
 import { logger } from '../utils/logger.js';
 export { Tensor } from 'onnxruntime-common';
 
@@ -176,8 +177,6 @@ export function deviceToExecutionProviders(device = null) {
     throw new Error(`Unsupported device: "${device}". Should be one of: ${supportedDevices.join(', ')}.`);
 }
 
-const IS_WEB_ENV = apis.IS_BROWSER_ENV || apis.IS_WEBWORKER_ENV;
-
 /**
  * Currently, Transformers.js doesn't support simultaneous loading of sessions in WASM/WebGPU.
  * For this reason, we need to chain the loading calls.
@@ -204,14 +203,23 @@ async function ensureWasmLoaded() {
         return wasmLoadPromise;
     }
 
+    // Check if we should load the WASM binary
     const shouldUseWasmCache =
         env.useWasmCache &&
         typeof ONNX_ENV?.wasm?.wasmPaths === 'object' &&
         ONNX_ENV?.wasm?.wasmPaths?.wasm &&
         ONNX_ENV?.wasm?.wasmPaths?.mjs;
 
-    // Check if we should load the WASM binary
     if (!shouldUseWasmCache) {
+        // In Deno's web runtime, the WASM factory must be loaded via blob URL so that Node.js detection
+        // can be patched out (see loadWasmFactory). Without caching, the factory is imported directly
+        // from its URL and Deno would crash trying to use Node.js APIs. useWasmCache defaults to true
+        // in this environment, so this only happens if the user explicitly disables it.
+        if (apis.IS_DENO_WEB_RUNTIME) {
+            throw new Error(
+                "env.useWasmCache=false is not supported in Deno's web runtime. Remove the useWasmCache override.",
+            );
+        }
         wasmLoadPromise = Promise.resolve();
         return wasmLoadPromise;
     }
@@ -222,7 +230,10 @@ async function ensureWasmLoaded() {
         // shouldUseWasmCache checks for wasmPaths.wasm and wasmPaths.mjs
         const urls = /** @type {{ wasm: string, mjs: string }} */ (ONNX_ENV.wasm.wasmPaths);
 
-        // Load and cache both the WASM binary and factory
+        // Load both in parallel; the .mjs blob URL is only kept if wasmBinary succeeded.
+        // ORT only sets locateFile when wasmBinary is provided (onnxruntime PR https://github.com/microsoft/onnxruntime/pull/27411), which
+        // prevents new URL(fileName, import.meta.url) from failing inside a blob URL factory.
+        let wasmBinaryLoaded = false;
         await Promise.all([
             // Load and cache the WASM binary
             urls.wasm && !isBlobURL(urls.wasm)
@@ -231,6 +242,7 @@ async function ensureWasmLoaded() {
                           const wasmBinary = await loadWasmBinary(toAbsoluteURL(urls.wasm));
                           if (wasmBinary) {
                               ONNX_ENV.wasm.wasmBinary = wasmBinary;
+                              wasmBinaryLoaded = true;
                           }
                       } catch (err) {
                           logger.warn('Failed to pre-load WASM binary:', err);
@@ -238,7 +250,7 @@ async function ensureWasmLoaded() {
                   })()
                 : Promise.resolve(),
 
-            // Load and cache the WASM factory
+            // Load and cache the WASM factory as a blob URL
             urls.mjs && !isBlobURL(urls.mjs)
                 ? (async () => {
                       try {
@@ -253,6 +265,12 @@ async function ensureWasmLoaded() {
                   })()
                 : Promise.resolve(),
         ]);
+
+        // If wasmBinary failed to load, revert wasmPaths.mjs to the original URL (factory can only be loaded from blob if ONNX_ENV.wasm.wasmBinary is set. @see ORT PR #27411)
+        if (!wasmBinaryLoaded) {
+            // @ts-ignore
+            ONNX_ENV.wasm.wasmPaths.mjs = urls.mjs;
+        }
     })();
 
     return wasmLoadPromise;
@@ -274,7 +292,7 @@ export async function createInferenceSession(buffer_or_path, session_options, se
             logSeverityLevel,
             ...session_options,
         });
-    const session = await (IS_WEB_ENV ? (webInitChain = webInitChain.then(load)) : load());
+    const session = await (apis.IS_WEB_ENV ? (webInitChain = webInitChain.then(load)) : load());
     session.config = session_config;
     return session;
 }
@@ -294,8 +312,7 @@ let webInferenceChain = Promise.resolve();
  */
 export async function runInferenceSession(session, ortFeed) {
     const run = () => session.run(ortFeed);
-    const output = await (IS_WEB_ENV ? (webInferenceChain = webInferenceChain.then(run)) : run());
-    return output;
+    return apis.IS_WEB_ENV ? (webInferenceChain = webInferenceChain.then(run)) : run();
 }
 
 /**
@@ -306,41 +323,8 @@ export async function runInferenceSession(session, ortFeed) {
 export function isONNXTensor(x) {
     return x instanceof ONNX.Tensor;
 }
-
 /** @type {import('onnxruntime-common').Env} */
 const ONNX_ENV = ONNX?.env;
-if (ONNX_ENV?.wasm) {
-    // Initialize wasm backend with suitable default settings.
-
-    // (Optional) Set path to wasm files. This will override the default path search behavior of onnxruntime-web.
-    // By default, we only do this if we are not in a service worker and the wasmPaths are not already set.
-    if (
-        // @ts-ignore Cannot find name 'ServiceWorkerGlobalScope'.ts(2304)
-        !(typeof ServiceWorkerGlobalScope !== 'undefined' && self instanceof ServiceWorkerGlobalScope) &&
-        ONNX_ENV.versions?.web &&
-        !ONNX_ENV.wasm.wasmPaths
-    ) {
-        const wasmPathPrefix = `https://cdn.jsdelivr.net/npm/onnxruntime-web@${ONNX_ENV.versions.web}/dist/`;
-
-        ONNX_ENV.wasm.wasmPaths = apis.IS_SAFARI
-            ? {
-                  mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.mjs`,
-                  wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.wasm`,
-              }
-            : {
-                  mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.mjs`,
-                  wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.wasm`,
-              };
-    }
-
-    // Users may wish to proxy the WASM backend to prevent the UI from freezing,
-    // However, this is not necessary when using WebGPU, so we default to false.
-    ONNX_ENV.wasm.proxy = false;
-}
-
-if (ONNX_ENV?.webgpu) {
-    ONNX_ENV.webgpu.powerPreference = 'high-performance';
-}
 
 /**
  * Check if ONNX's WASM backend is being proxied.
@@ -351,21 +335,56 @@ 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];
-}
+if (ONNX_ENV) {
+    if (ONNX_ENV.wasm) {
+        // Initialize wasm backend with suitable default settings.
+
+        // (Optional) Set path to wasm files. This will override the default path search behavior of onnxruntime-web.
+        // By default, we only do this if we are not in a service worker and the wasmPaths are not already set.
+        if (
+            // @ts-ignore Cannot find name 'ServiceWorkerGlobalScope'.ts(2304)
+            !(typeof ServiceWorkerGlobalScope !== 'undefined' && self instanceof ServiceWorkerGlobalScope) &&
+            ONNX_ENV.versions?.web &&
+            !ONNX_ENV.wasm.wasmPaths
+        ) {
+            const wasmPathPrefix = `https://cdn.jsdelivr.net/npm/onnxruntime-web@${ONNX_ENV.versions.web}/dist/`;
+
+            ONNX_ENV.wasm.wasmPaths = apis.IS_SAFARI
+                ? {
+                      mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.mjs`,
+                      wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.wasm`,
+                  }
+                : {
+                      mjs: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.mjs`,
+                      wasm: `${wasmPathPrefix}ort-wasm-simd-threaded.asyncify.wasm`,
+                  };
+        }
+
+        // Users may wish to proxy the WASM backend to prevent the UI from freezing,
+        // However, this is not necessary when using WebGPU, so we default to false.
+        ONNX_ENV.wasm.proxy = false;
+    }
+
+    if (ONNX_ENV.webgpu) {
+        ONNX_ENV.webgpu.powerPreference = 'high-performance';
+    }
 
-// Set the initial log level to be the default Transformers.js log level.
-setLogLevel(env.logLevel ?? LogLevel.WARNING);
+    /**
+     * 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];
+    }
 
-// Expose ONNX environment variables to `env.backends.onnx`
-env.backends.onnx = {
-    ...ONNX_ENV,
-    setLogLevel,
-};
+    // 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,
+        setLogLevel,
+    };
+}

package/src/backends/utils/cacheWasm.js

@@ -1,12 +1,11 @@
+import { apis, env } from '../../env.js';
 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.
  * @param {string} url The URL of the file to load.
- * @returns {Promise<Response|import('../../utils/hub/files.js').FileResponse|null|string>} The response object, or null if loading failed.
+ * @returns {Promise<Response|import('../../utils/hub/FileResponse.js').FileResponse|null|string>} The response object, or null if loading failed.
  */
 async function loadAndCacheFile(url) {
     const fileName = url.split('/').pop();
@@ -65,58 +64,38 @@ export async function loadWasmBinary(wasmURL) {
 }
 
 /**
- * Loads and caches the WASM Factory for ONNX Runtime.
+ * Loads and caches the WASM Factory (.mjs file) for ONNX Runtime.
+ * Creates a blob URL from cached content (when safe) to bridge Cache API with dynamic imports used in ORT.
  * @param {string} libURL The URL of the WASM Factory to load.
- * @returns {Promise<string|null>} The blob URL of the WASM Factory, or null if loading failed.
+ * @returns {Promise<string|null>} The blob URL (if enabled), original URL (if disabled), or null if loading failed.
  */
 export async function loadWasmFactory(libURL) {
+    // We can't use Blob URLs in some environments (Service Workers, Chrome extensions) due to security restrictions on dynamic import() of blob URLs.
+    // In such cases, just return the original URL and don't bother caching since dynamic import() won't use the Cache API anyway.
+    // See https://github.com/huggingface/transformers.js/issues/1532.
+    if (apis.IS_SERVICE_WORKER_ENV || apis.IS_CHROME_AVAILABLE) {
+        return libURL;
+    }
+
+    // Fetch from cache or network, then create blob URL
     const response = await loadAndCacheFile(libURL);
     if (!response || typeof response === 'string') return null;
 
     try {
         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.replaceAll('import.meta.url', `"${baseUrl}"`);
+
+        // Handle the case where we are importing the bundled version of the library in Deno (e.g., via CDN or local file),
+        // where we need to patch out Node.js detection in the factory. Without this, Deno (which exposes globalThis.process.versions.node)
+        // would enter the Node.js branch and try to use Node.js APIs (worker_threads, fs, etc.) that aren't used in the bundled web version.
+        // Only needed for the asyncify (single-threaded) variant loaded via blob URL. The module-level pthread auto-start code is unreachable since asyncify never spawns workers.
+        // See https://github.com/huggingface/transformers.js/pull/1546/ for more information.
+        //
+        // NOTE: This does not affect default usage via Deno (i.e., imported via npm: prefix), since we'll be using onnxruntime-node (Native) instead of onnxruntime-web (WASM).
         code = code.replaceAll('globalThis.process?.versions?.node', 'false');
         const blob = new Blob([code], { type: 'text/javascript' });
         return URL.createObjectURL(blob);
     } catch (error) {
-        logger.warn('Failed to read WASM binary:', error);
+        logger.warn('Failed to read WASM factory:', error);
         return null;
     }
 }
-
-/**
- * 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/configs.js

@@ -76,6 +76,7 @@ function getNormalizedConfig(config) {
         case 'mistral3':
         case 'qwen2_5_vl':
         case 'qwen3_vl':
+        case 'qwen3_vl_moe':
             // @ts-expect-error TS2339
             init_normalized_config = getNormalizedConfig(config.text_config);
             break;
@@ -132,9 +133,12 @@ function getNormalizedConfig(config) {
         case 'mistral':
         case 'starcoder2':
         case 'qwen2':
+        case 'qwen2_moe':
         case 'qwen2_vl':
         case 'qwen2_5_vl_text':
+        case 'qwen3_moe':
         case 'qwen3_vl_text':
+        case 'qwen3_vl_moe_text':
         case 'phi':
         case 'phi3':
         case 'phi3_v':
@@ -348,7 +352,7 @@ export function getCacheShapes(config, options) {
             }
         }
         return cache_values;
-    } else if (['qwen3_5', 'qwen3_5_moe'].includes(config.model_type)) {
+    } else if (['qwen3_next', 'qwen3_5_text', 'qwen3_5_moe_text', 'olmo_hybrid'].includes(config.model_type)) {
         const pkv_prefix = options?.prefix ?? 'past_key_values';
         const conv_prefix = pkv_prefix === 'present' ? 'present' : 'past';
 
@@ -365,13 +369,11 @@ export function getCacheShapes(config, options) {
             linear_key_head_dim,
             linear_value_head_dim,
             linear_conv_kernel_dim,
-        } = /** @type {any} */ (config).text_config;
+        } = /** @type {any} */ (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) {
@@ -380,7 +382,14 @@ export function getCacheShapes(config, options) {
                     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];
+                if (config.model_type === 'olmo_hybrid') {
+                    cache_values[`${conv_prefix}_conv.${i}.key`] = [batch_size, key_dim, linear_conv_kernel_dim];
+                    cache_values[`${conv_prefix}_conv.${i}.value`] = [batch_size, value_dim, linear_conv_kernel_dim];
+                    cache_values[`${conv_prefix}_conv.${i}.query`] = [batch_size, key_dim, linear_conv_kernel_dim];
+                } else {
+                    const conv_dim = key_dim * 2 + value_dim;
+                    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,
@@ -392,7 +401,10 @@ export function getCacheShapes(config, options) {
             }
         }
         return cache_values;
+    } else if (['qwen3_5', 'qwen3_5_moe'].includes(config.model_type)) {
+        return getCacheShapes(/**@type {any} */ (config).text_config, options);
     }
+
     return getKeyValueShapes(config, options);
 }
 

package/src/env.js

@@ -26,11 +26,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 import url from 'node:url';
 
-const VERSION = '4.0.0-next.5';
+const VERSION = '4.0.0-next.6';
+
+const HAS_SELF = typeof self !== 'undefined';
 
 const IS_FS_AVAILABLE = !isEmpty(fs);
 const IS_PATH_AVAILABLE = !isEmpty(path);
-const IS_WEB_CACHE_AVAILABLE = typeof self !== 'undefined' && 'caches' in self;
+const IS_WEB_CACHE_AVAILABLE = HAS_SELF && 'caches' in self;
 
 // Runtime detection
 const IS_DENO_RUNTIME = typeof globalThis.Deno !== 'undefined';
@@ -44,14 +46,24 @@ const IS_NODE_ENV = IS_PROCESS_AVAILABLE && process?.release?.name === 'node' &&
 // Check if various APIs are available (depends on environment)
 const IS_BROWSER_ENV = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 const IS_WEBWORKER_ENV =
-    typeof self !== 'undefined' &&
+    HAS_SELF &&
     ['DedicatedWorkerGlobalScope', 'ServiceWorkerGlobalScope', 'SharedWorkerGlobalScope'].includes(
         self.constructor?.name,
     );
+const IS_WEB_ENV = IS_BROWSER_ENV || IS_WEBWORKER_ENV || IS_DENO_WEB_RUNTIME;
+
 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';
 
+const IS_CHROME_AVAILABLE =
+    // @ts-ignore - chrome may not exist in all environments
+    typeof chrome !== 'undefined' && typeof chrome.runtime !== 'undefined' && typeof chrome.runtime.id === 'string';
+
+const IS_SERVICE_WORKER_ENV =
+    // @ts-ignore - ServiceWorkerGlobalScope may not exist in all environments
+    typeof ServiceWorkerGlobalScope !== 'undefined' && HAS_SELF && self instanceof ServiceWorkerGlobalScope;
+
 /**
  * Check if the current environment is Safari browser.
  * Works in both browser and web worker contexts.
@@ -90,6 +102,15 @@ export const apis = Object.freeze({
     /** Whether we are running in a web worker environment */
     IS_WEBWORKER_ENV,
 
+    /** Whether we are running in a web-like environment (browser, web worker, or Deno web runtime) */
+    IS_WEB_ENV,
+
+    /** Whether we are running in a service worker environment */
+    IS_SERVICE_WORKER_ENV,
+
+    /** Whether we are running in Deno's web runtime (CDN imports, Cache API available, no filesystem) */
+    IS_DENO_WEB_RUNTIME,
+
     /** Whether the Cache API is available */
     IS_WEB_CACHE_AVAILABLE,
 
@@ -116,6 +137,9 @@ export const apis = Object.freeze({
 
     /** Whether the crypto API is available */
     IS_CRYPTO_AVAILABLE,
+
+    /** Whether the Chrome runtime API is available */
+    IS_CHROME_AVAILABLE,
 });
 
 const RUNNING_LOCALLY = IS_FS_AVAILABLE && IS_PATH_AVAILABLE;
@@ -197,9 +221,8 @@ export const LogLevel = Object.freeze({
  * @property {boolean} useCustomCache Whether to use a custom cache system (defined by `customCache`), defaults to `false`.
  * @property {import('./utils/cache.js').CacheInterface|null} customCache The custom cache to use. Defaults to `null`. Note: this must be an object which
  * implements the `match` and `put` functions of the Web Cache API. For more information, see https://developer.mozilla.org/en-US/docs/Web/API/Cache.
- * @property {boolean} useWasmCache Whether to pre-load and cache WASM binaries for ONNX Runtime. Defaults to `true` when cache is available.
- * 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 {boolean} useWasmCache Whether to pre-load and cache WASM binaries and the WASM factory (.mjs) for ONNX Runtime.
+ * Defaults to `true` when cache is available. This can improve performance and enables offline usage by avoiding repeated downloads.
  * @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`.
  */

package/src/models/auto/modeling_auto.js

@@ -62,6 +62,19 @@ class PretrainedMixin {
      */
     static BASE_IF_FAIL = false;
 
+    /**
+     * Check whether this AutoModel class supports a given model type.
+     * @param {string} model_type The model type from config (e.g., 'bert', 'whisper').
+     * @returns {boolean} Whether this class can handle the given model type.
+     */
+    static supports(model_type) {
+        if (!this.MODEL_CLASS_MAPPINGS) return false;
+        for (const mapping of this.MODEL_CLASS_MAPPINGS) {
+            if (mapping.has(model_type)) return true;
+        }
+        return this.BASE_IF_FAIL;
+    }
+
     /** @type {typeof PreTrainedModel.from_pretrained} */
     static async from_pretrained(
         pretrained_model_name_or_path,
@@ -97,7 +110,7 @@ class PretrainedMixin {
         if (!this.MODEL_CLASS_MAPPINGS) {
             throw new Error('`MODEL_CLASS_MAPPINGS` not implemented for this type of `AutoClass`: ' + this.name);
         }
-        const model_type = options.config.model_type;
+        const { model_type } = options.config;
         for (const MODEL_CLASS_MAPPING of this.MODEL_CLASS_MAPPINGS) {
             let modelInfo = MODEL_CLASS_MAPPING.get(model_type);
             if (!modelInfo) {

package/src/models/modeling_utils.js

@@ -37,6 +37,26 @@ import { pick } from '../utils/core.js';
 import { ModelOutput } from './modeling_outputs.js';
 import { logger } from '../utils/logger.js';
 
+/**
+ * Extract the past sequence length from a past_key_values object.
+ * For standard models, all entries are attention KV caches with shape [batch, heads, seq_len, head_dim].
+ * For hybrid models (e.g., Qwen3.5 with conv/recurrent + attention layers), the first entry
+ * may be a conv or recurrent state whose dims don't encode a sequence length.
+ * This function finds a `past_key_values.*` entry (standard attention cache) to determine the true past length.
+ *
+ * @param {Record<string, Tensor>} past_key_values
+ * @returns {number} The past sequence length.
+ */
+export function getPastLength(past_key_values) {
+    for (const name in past_key_values) {
+        if (name.startsWith('past_key_values.')) {
+            return past_key_values[name].dims.at(-2);
+        }
+    }
+    // Fallback for non-hybrid models (all entries are attention KV)
+    return Object.values(past_key_values)[0].dims.at(-2);
+}
+
 /**
  * Converts an array or Tensor of integers to an int64 Tensor.
  * @param {any[]|Tensor} items The input integers to be converted.
@@ -1431,7 +1451,7 @@ export async function decoder_forward(self, model_inputs, is_encoder_decoder = f
  * @param {Tensor} [params.attention_mask=null]
  * @param {Tensor} [params.position_ids=null]
  * @param {Tensor} [params.inputs_embeds=null]
- * @param {Tensor} [params.past_key_values=null]
+ * @param {Record<string, Tensor>} [params.past_key_values=null]
  * @param {Object} [params.generation_config=null]
  * @param {Object} [params.logits_processor=null]
  * @returns {Promise<Tensor>} The model's output tensor
@@ -1485,7 +1505,7 @@ export async function generic_text_to_text_forward(
         } else if (past_key_values && modality_values && input_ids.dims[1] === 1) {
             // This branch handles the cache case.
             const target_length = input_ids.dims[1]; // always 1
-            const past_length = Object.values(past_key_values)[0].dims.at(-2);
+            const past_length = getPastLength(past_key_values);
 
             attention_mask = cat(
                 [
@@ -1499,11 +1519,19 @@ export async function generic_text_to_text_forward(
 
     if (!position_ids) {
         if (
-            ['qwen2_vl', 'qwen2_5_vl_text', 'qwen3_vl_text', 'qwen3_5_text', 'qwen3_5_moe_text'].includes(
-                self.config.model_type,
-            )
+            // Handle special case for qwen vl models
+            [
+                'qwen2_vl',
+                'qwen2_5_vl',
+                'qwen2_5_vl_text',
+                'qwen3_vl',
+                'qwen3_vl_text',
+                'qwen3_5',
+                'qwen3_5_text',
+                'qwen3_5_moe',
+                'qwen3_5_moe_text',
+            ].includes(self.config.model_type)
         ) {
-            // Special case for qwen vl models
             // @ts-ignore
             const { image_grid_thw, video_grid_thw } = kwargs;
             [position_ids] = self.get_rope_index(input_ids, image_grid_thw, video_grid_thw, attention_mask);
@@ -1616,7 +1644,7 @@ export function create_position_ids(model_inputs, past_key_values = null, start_
 }
 
 export function decoder_prepare_inputs_for_generation(self, input_ids, model_inputs, generation_config) {
-    const past_length = model_inputs.past_key_values ? Object.values(model_inputs.past_key_values)[0].dims.at(-2) : 0;
+    const past_length = model_inputs.past_key_values ? getPastLength(model_inputs.past_key_values) : 0;
 
     if (!model_inputs.attention_mask) {
         // If the attention mask is not provided, we attempt to infer based on provided inputs

package/src/models/models.js

@@ -108,6 +108,7 @@ export * from './nomic_bert/modeling_nomic_bert.js';
 export * from './olmo/modeling_olmo.js';
 export * from './olmo2/modeling_olmo2.js';
 export * from './olmo3/modeling_olmo3.js';
+export * from './olmo_hybrid/modeling_olmo_hybrid.js';
 export * from './openelm/modeling_openelm.js';
 export * from './opt/modeling_opt.js';
 export * from './owlv2/modeling_owlv2.js';
@@ -122,10 +123,14 @@ export * from './phi3_v/modeling_phi3_v.js';
 export * from './pvt/modeling_pvt.js';
 export * from './pyannote/modeling_pyannote.js';
 export * from './qwen2/modeling_qwen2.js';
+export * from './qwen2_moe/modeling_qwen2_moe.js';
 export * from './qwen2_vl/modeling_qwen2_vl.js';
 export * from './qwen2_5_vl/modeling_qwen2_5_vl.js';
 export * from './qwen3/modeling_qwen3.js';
+export * from './qwen3_moe/modeling_qwen3_moe.js';
+export * from './qwen3_next/modeling_qwen3_next.js';
 export * from './qwen3_vl/modeling_qwen3_vl.js';
+export * from './qwen3_vl_moe/modeling_qwen3_vl_moe.js';
 export * from './qwen3_5/modeling_qwen3_5.js';
 export * from './qwen3_5_moe/modeling_qwen3_5_moe.js';
 export * from './resnet/modeling_resnet.js';

package/src/models/olmo_hybrid/modeling_olmo_hybrid.js

@@ -0,0 +1,5 @@
+import { PreTrainedModel } from '../modeling_utils.js';
+
+export class OlmoHybridPreTrainedModel extends PreTrainedModel {}
+export class OlmoHybridModel extends OlmoHybridPreTrainedModel {}
+export class OlmoHybridForCausalLM extends OlmoHybridPreTrainedModel {}

package/src/models/qwen2_moe/modeling_qwen2_moe.js

@@ -0,0 +1,5 @@
+import { PreTrainedModel } from '../modeling_utils.js';
+
+export class Qwen2MoePreTrainedModel extends PreTrainedModel {}
+export class Qwen2MoeModel extends Qwen2MoePreTrainedModel {}
+export class Qwen2MoeForCausalLM extends Qwen2MoePreTrainedModel {}