@huggingface/transformers 4.0.0-next.0 → 4.0.0-next.10

package/src/models/qwen2_vl/modeling_qwen2_vl.js

@@ -17,6 +17,172 @@ export class Qwen2VLPreTrainedModel extends PreTrainedModel {
     ];
 }
 export class Qwen2VLForConditionalGeneration extends Qwen2VLPreTrainedModel {
+    // NOTE: This is used as the base class for all Qwen VL models and their CausalLM variants.
+    // CausalLM variants (e.g., Qwen2VLForCausalLM) extend this class but load only
+    // embed_tokens + decoder_model_merged (no vision_encoder) via MultimodalLanguageModelOnly type.
+    image_grid_thw_name = 'grid_thw';
+
+    /**
+     * Compute text-only 3D rope position IDs (all 3 dims get the same 1D positions).
+     * @param {Tensor} input_ids
+     * @param {Tensor} attention_mask
+     * @returns {[Tensor, Tensor]} [position_ids, mrope_position_deltas]
+     */
+    _get_text_only_rope_index(input_ids, attention_mask) {
+        if (attention_mask) {
+            const { data, dims } = cumsum_masked_fill(attention_mask);
+
+            const position_ids = BigInt64Array.from({ length: 3 * data.length }, (_, i) => data[i % data.length]);
+            /** @type {bigint[]} */
+            const mrope_position_deltas = Array.from(
+                { length: dims[0] },
+                (_, i) => max(data.subarray(dims[1] * i, dims[1] * (i + 1)))[0] + 1n + BigInt(dims[1]),
+            );
+
+            return [
+                new Tensor('int64', position_ids, [3, ...dims]),
+                new Tensor('int64', mrope_position_deltas, [mrope_position_deltas.length, 1]),
+            ];
+        } else {
+            const [batch_size, seq_length] = input_ids.dims;
+            const position_ids = BigInt64Array.from({ length: 3 * batch_size * seq_length }, (_, i) =>
+                BigInt(Math.floor((i % seq_length) / batch_size)),
+            );
+
+            return [new Tensor('int64', position_ids, [3, ...input_ids.dims]), zeros([batch_size, 1])];
+        }
+    }
+
+    /**
+     * Reorder per-segment position ID lists from [seg1[t,h,w], seg2[t,h,w], ...] into
+     * global [all_t, all_h, all_w] order, then write back into the position_ids array
+     * respecting attention mask.
+     * @param {number[][]} llm_pos_ids_list List of per-segment position arrays, each of length 3*seg_len
+     * @param {number[]} attn_mask Attention mask for this batch element
+     * @param {number[][][]} position_ids_list [3][batch][seq] output array to write into
+     * @param {number} batch_idx Current batch index
+     * @returns {number[]} Flat reordered positions of length total_len
+     */
+    _reorder_and_write_positions(llm_pos_ids_list, attn_mask, position_ids_list, batch_idx) {
+        const total_len = llm_pos_ids_list.reduce((acc, x) => acc + x.length, 0);
+        const llm_positions = new Array(total_len);
+        let index = 0;
+        for (let x = 0; x < 3; ++x) {
+            for (const val of llm_pos_ids_list) {
+                const seg_len = val.length / 3;
+                for (let z = x * seg_len; z < (x + 1) * seg_len; ++z) {
+                    llm_positions[index++] = val[z];
+                }
+            }
+        }
+
+        let count = 0;
+        for (let y = 0; y < attn_mask.length; ++y) {
+            if (attn_mask[y] == 1) {
+                for (let x = 0; x < 3; ++x) {
+                    position_ids_list[x][batch_idx][y] = llm_positions[(x * total_len) / 3 + count];
+                }
+                ++count;
+            }
+        }
+
+        return llm_positions;
+    }
+
+    /**
+     * Build per-batch position ID segments for multimodal rope.
+     * Override this in subclasses to change how vision/text segments are identified and positioned.
+     * @param {object} params
+     * @param {any[]} params.filtered_ids - attention-masked token IDs for this batch element
+     * @param {any[][]} params.image_grid_thw_list - all image grid dimensions
+     * @param {any[][]} params.video_grid_thw_list - all video grid dimensions
+     * @param {number} params.spatial_merge_size
+     * @param {{image_index: number, video_index: number}} params.state - mutable counters shared across batches
+     * @returns {number[][]} llm_pos_ids_list - segments of [t..., h..., w...] positions
+     */
+    _get_multimodal_rope_positions({
+        filtered_ids,
+        image_grid_thw_list,
+        video_grid_thw_list,
+        spatial_merge_size,
+        state,
+    }) {
+        // @ts-ignore
+        const { image_token_id, video_token_id, vision_start_token_id } = this.config;
+
+        const ids = filtered_ids;
+        const vision_start_indices = ids.reduce((acc, x, idx) => {
+            if (x == vision_start_token_id) acc.push(idx);
+            return acc;
+        }, []);
+
+        const vision_tokens = vision_start_indices.map((x) => ids[x + 1]);
+        const image_nums = vision_tokens.filter((x) => x == image_token_id).length;
+        const video_nums = vision_tokens.filter((x) => x == video_token_id).length;
+
+        /** @type {number[][]} */
+        const llm_pos_ids_list = [];
+        let st = 0;
+        let remain_images = image_nums;
+        let remain_videos = video_nums;
+        for (let j = 0; j < vision_tokens.length; ++j) {
+            const next_image_token = ids.findIndex((x, i) => i > st && x == image_token_id);
+            const next_video_token = ids.findIndex((x, i) => i > st && x == video_token_id);
+
+            const ed_image = remain_images > 0 && next_image_token !== -1 ? next_image_token : ids.length + 1;
+            const ed_video = remain_videos > 0 && next_video_token !== -1 ? next_video_token : ids.length + 1;
+
+            let ed;
+            let t, h, w;
+            if (ed_image < ed_video) {
+                [t, h, w] = image_grid_thw_list[state.image_index];
+                ++state.image_index;
+                --remain_images;
+                ed = ed_image;
+            } else {
+                [t, h, w] = video_grid_thw_list[state.video_index];
+                ++state.video_index;
+                --remain_videos;
+                ed = ed_video;
+            }
+
+            const [llm_grid_t, llm_grid_h, llm_grid_w] = [
+                Number(t),
+                Math.floor(Number(h) / spatial_merge_size),
+                Math.floor(Number(w) / spatial_merge_size),
+            ];
+            const text_len = ed - st;
+            const st_idx = llm_pos_ids_list.length > 0 ? max(llm_pos_ids_list.at(-1))[0] + 1 : 0;
+
+            llm_pos_ids_list.push(Array.from({ length: 3 * text_len }, (_, i) => st_idx + (i % text_len)));
+
+            const offset = text_len + st_idx;
+            const grid_size = llm_grid_t * llm_grid_h * llm_grid_w;
+            const t_index = Array.from(
+                { length: grid_size },
+                (_, i) => offset + Math.floor(i / (llm_grid_h * llm_grid_w)),
+            );
+            const h_index = Array.from(
+                { length: grid_size },
+                (_, i) => offset + (Math.floor(i / llm_grid_w) % llm_grid_h),
+            );
+            const w_index = Array.from({ length: grid_size }, (_, i) => offset + (i % llm_grid_w));
+
+            llm_pos_ids_list.push([t_index, h_index, w_index].flat());
+
+            st = ed + grid_size;
+        }
+
+        if (st < ids.length) {
+            const st_idx = llm_pos_ids_list.length > 0 ? max(llm_pos_ids_list.at(-1))[0] + 1 : 0;
+            const text_len = ids.length - st;
+
+            llm_pos_ids_list.push(Array.from({ length: 3 * text_len }, (_, i) => st_idx + (i % text_len)));
+        }
+
+        return llm_pos_ids_list;
+    }
+
     /**
      * Calculate the 3D rope index based on image and video's temporal, height and width in LLM.
      *
@@ -46,137 +212,49 @@ export class Qwen2VLForConditionalGeneration extends Qwen2VLPreTrainedModel {
      * @param {Tensor} input_ids Indices of input sequence tokens in the vocabulary. Tensor of shape `(batch_size, sequence_length)`.
      * @param {Tensor} image_grid_thw (Optional) The temporal, height and width of feature shape of each image in LLM. Tensor of shape `(num_images, 3)`.
      * @param {Tensor} video_grid_thw (Optional) The temporal, height and width of feature shape of each video in LLM. Tensor of shape `(num_videos, 3)`.
-     * @param {Tensor} attention_mask (Optional) Mask to avoid performing attention on padding token indices. Tensor of shape `(batch_size, sequence_length)`. Mask values selected in `[0, 1]`:
-     * - 1 for tokens that are **not masked**,
-     * - 0 for tokens that are **masked**.
-     * @returns {[Tensor, Tensor]} [position_ids, mrope_position_deltas] with:
-     * - position_ids: Tensor of shape `(3, batch_size, sequence_length)`.
-     * - mrope_position_deltas: Tensor of shape `(batch_size)`.
+     * @param {Tensor} attention_mask (Optional) Mask to avoid performing attention on padding token indices. Tensor of shape `(batch_size, sequence_length)`.
+     * @returns {[Tensor, Tensor]} [position_ids, mrope_position_deltas]
      */
     get_rope_index(input_ids, image_grid_thw, video_grid_thw, attention_mask) {
         // @ts-ignore
-        const { vision_config, image_token_id, video_token_id, vision_start_token_id } = this.config;
+        const { vision_config } = this.config;
         const spatial_merge_size = vision_config.spatial_merge_size ?? 2;
 
-        const mrope_position_deltas = [];
         if (image_grid_thw || video_grid_thw) {
-            let total_input_ids = input_ids.tolist();
+            const total_input_ids = input_ids.tolist();
             if (!attention_mask) {
                 attention_mask = ones_like(input_ids);
             }
 
             const attention_mask_list = attention_mask.tolist();
-            const position_ids_list = Array.from({ length: 3 }, (_) =>
-                Array.from({ length: input_ids.dims[0] }, (_) => Array.from({ length: input_ids.dims[1] }, (_) => 1)),
+            const position_ids_list = Array.from({ length: 3 }, () =>
+                Array.from({ length: input_ids.dims[0] }, () => Array.from({ length: input_ids.dims[1] }, () => 0)),
             );
 
             const image_grid_thw_list = image_grid_thw ? image_grid_thw.tolist() : [];
             const video_grid_thw_list = video_grid_thw ? video_grid_thw.tolist() : [];
+            const state = { image_index: 0, video_index: 0 };
 
-            let image_index = 0;
-            let video_index = 0;
+            const mrope_position_deltas = [];
             for (let i = 0; i < total_input_ids.length; ++i) {
-                const ids = total_input_ids[i].filter((_, j) => attention_mask_list[i][j] == 1);
-
-                const vision_start_indices = ids.reduce((acc, x, idx) => {
-                    if (x == vision_start_token_id) acc.push(idx);
-                    return acc;
-                }, []);
-
-                const vision_tokens = vision_start_indices.map((x) => ids[x + 1]);
-                const image_nums = vision_tokens.filter((x) => x == image_token_id).length;
-                const video_nums = vision_tokens.filter((x) => x == video_token_id).length;
-
-                /** @type {number[][]} */
-                let llm_pos_ids_list = [];
-                let st = 0;
-                let remain_images = image_nums;
-                let remain_videos = video_nums;
-                for (let j = 0; j < vision_tokens.length; ++j) {
-                    const next_image_token = ids.findIndex((x, i) => i > st && x == image_token_id);
-                    const next_video_token = ids.findIndex((x, i) => i > st && x == video_token_id);
-
-                    const ed_image = remain_images > 0 && next_image_token !== -1 ? next_image_token : ids.length + 1;
-
-                    const ed_video = remain_videos > 0 && next_video_token !== -1 ? next_video_token : ids.length + 1;
-
-                    let ed;
-                    let t, h, w;
-                    if (ed_image < ed_video) {
-                        [t, h, w] = image_grid_thw_list[image_index];
-                        ++image_index;
-                        --remain_images;
-                        ed = ed_image;
-                    } else {
-                        [t, h, w] = video_grid_thw_list[video_index];
-                        ++video_index;
-                        --remain_videos;
-                        ed = ed_video;
-                    }
-
-                    const [llm_grid_t, llm_grid_h, llm_grid_w] = [
-                        Number(t),
-                        Math.floor(Number(h) / spatial_merge_size),
-                        Math.floor(Number(w) / spatial_merge_size),
-                    ];
-                    const text_len = ed - st;
-                    const st_idx = llm_pos_ids_list.length > 0 ? max(llm_pos_ids_list.at(-1))[0] + 1 : 0;
-
-                    llm_pos_ids_list.push(Array.from({ length: 3 * text_len }, (_, i) => st_idx + (i % text_len)));
-
-                    const offset = text_len + st_idx;
-                    const grid_size = llm_grid_t * llm_grid_h * llm_grid_w;
-                    const t_index = Array.from(
-                        { length: grid_size },
-                        (_, i) => offset + Math.floor(i / (llm_grid_h * llm_grid_w)),
-                    );
-                    const h_index = Array.from(
-                        { length: grid_size },
-                        (_, i) => offset + (Math.floor(i / llm_grid_w) % llm_grid_h),
-                    );
-                    const w_index = Array.from({ length: grid_size }, (_, i) => offset + (i % llm_grid_w));
-
-                    llm_pos_ids_list.push([t_index, h_index, w_index].flat());
-
-                    st = ed + grid_size;
-                }
-
-                if (st < ids.length) {
-                    const st_idx = llm_pos_ids_list.length > 0 ? max(llm_pos_ids_list.at(-1))[0] + 1 : 0;
-                    const text_len = ids.length - st;
+                const filtered_ids = total_input_ids[i].filter((_, j) => attention_mask_list[i][j] == 1);
 
-                    llm_pos_ids_list.push(Array.from({ length: 3 * text_len }, (_, i) => st_idx + (i % text_len)));
-                }
+                const llm_pos_ids_list = this._get_multimodal_rope_positions({
+                    filtered_ids,
+                    image_grid_thw_list,
+                    video_grid_thw_list,
+                    spatial_merge_size,
+                    state,
+                });
 
-                // NOTE: Each item in llm_pos_ids_list is an array of shape (3, text_len),
-                // meaning to perform concatenation along dim=1, we can do the following:
-                const num_items = llm_pos_ids_list.reduce((acc, x) => acc + x.length, 0);
-                /** @type {number[]} */
-                const llm_positions = new Array(num_items);
-                let index = 0;
-                for (let x = 0; x < 3; ++x) {
-                    for (let y = 0; y < llm_pos_ids_list.length; ++y) {
-                        const val = llm_pos_ids_list[y];
-                        const text_len = val.length / 3;
-                        for (let z = x * text_len; z < (x + 1) * text_len; ++z) {
-                            llm_positions[index++] = val[z];
-                        }
-                    }
-                }
-
-                let count = 0;
-                const attn_mask = attention_mask_list[i];
-                for (let y = 0; y < attn_mask.length; ++y) {
-                    if (attn_mask[y] == 1) {
-                        for (let x = 0; x < 3; ++x) {
-                            position_ids_list[x][i][y] = llm_positions[(x * num_items) / 3 + count];
-                        }
-                        ++count;
-                    }
-                }
+                const llm_positions = this._reorder_and_write_positions(
+                    llm_pos_ids_list,
+                    attention_mask_list[i],
+                    position_ids_list,
+                    i,
+                );
 
-                const max_llm_positions = max(llm_positions)[0];
-                mrope_position_deltas.push(max_llm_positions + 1 - total_input_ids[i].length);
+                mrope_position_deltas.push(max(llm_positions)[0] + 1 - total_input_ids[i].length);
             }
 
             return [
@@ -184,35 +262,17 @@ export class Qwen2VLForConditionalGeneration extends Qwen2VLPreTrainedModel {
                 new Tensor('int64', mrope_position_deltas, [mrope_position_deltas.length, 1]),
             ];
         } else {
-            // Text-only
-            if (attention_mask) {
-                const { data, dims } = cumsum_masked_fill(attention_mask);
-
-                const position_ids = BigInt64Array.from({ length: 3 * data.length }, (_, i) => data[i % data.length]);
-                /** @type {bigint[]} */
-                const mrope_position_deltas = Array.from(
-                    { length: dims[0] },
-                    (_, i) => max(data.subarray(dims[1] * i, dims[1] * (i + 1)))[0] + 1n + BigInt(dims[1]),
-                );
-
-                return [
-                    new Tensor('int64', position_ids, [3, ...dims]),
-                    new Tensor('int64', mrope_position_deltas, [mrope_position_deltas.length, 1]),
-                ];
-            } else {
-                const [batch_size, seq_length] = input_ids.dims;
-                const position_ids = BigInt64Array.from({ length: 3 * batch_size * seq_length }, (_, i) =>
-                    BigInt(Math.floor((i % seq_length) / batch_size)),
-                );
-
-                return [new Tensor('int64', position_ids, [3, ...input_ids.dims]), zeros([batch_size, 1])];
-            }
+            return this._get_text_only_rope_index(input_ids, attention_mask);
         }
     }
 
     async encode_image({ pixel_values, image_grid_thw }) {
-        const features = (await sessionRun(this.sessions['vision_encoder'], { pixel_values, grid_thw: image_grid_thw }))
-            .image_features;
+        const features = (
+            await sessionRun(this.sessions['vision_encoder'], {
+                pixel_values,
+                [this.image_grid_thw_name]: image_grid_thw,
+            })
+        ).image_features;
         return features;
     }
 
@@ -226,20 +286,55 @@ export class Qwen2VLForConditionalGeneration extends Qwen2VLPreTrainedModel {
 
     prepare_inputs_for_generation(input_ids, model_inputs, generation_config) {
         // Overwritten -- in specific circumstances we don't want to forward image inputs to the model
-        if (model_inputs.attention_mask && !model_inputs.position_ids) {
-            // Calculate position_ids and rope_deltas
-            if (!model_inputs.past_key_values) {
-                [model_inputs.position_ids, model_inputs.rope_deltas] = this.get_rope_index(
+        if (!model_inputs.attention_mask || model_inputs.position_ids) {
+            return model_inputs;
+        }
+
+        const session = this.sessions['decoder_model_merged'] ?? this.sessions['model'];
+        if (!session.inputNames.includes('position_ids')) {
+            return model_inputs;
+        }
+
+        // Calculate position_ids and rope_deltas
+        if (!model_inputs.past_key_values) {
+            [model_inputs.position_ids, model_inputs.rope_deltas] = this.get_rope_index(
+                model_inputs.input_ids,
+                model_inputs.image_grid_thw,
+                model_inputs.video_grid_thw,
+                model_inputs.attention_mask,
+            );
+        } else {
+            model_inputs.pixel_values = null;
+            // model_inputs.pixel_values_videos = null;
+
+            const past_length = model_inputs.past_key_values.get_seq_length();
+
+            if (past_length < model_inputs.input_ids.dims[1]) {
+                // Externally provided `past_key_values` with full input_ids:
+                // Compute full position_ids, then slice to only the new (unprocessed) tokens.
+                const [full_position_ids, rope_deltas] = this.get_rope_index(
                     model_inputs.input_ids,
                     model_inputs.image_grid_thw,
                     model_inputs.video_grid_thw,
                     model_inputs.attention_mask,
                 );
+                model_inputs.rope_deltas = rope_deltas;
+                model_inputs.position_ids = full_position_ids.slice(null, null, [past_length, null]);
+                model_inputs.input_ids = model_inputs.input_ids.slice(null, [past_length, null]);
             } else {
-                model_inputs.pixel_values = null;
-                // model_inputs.pixel_values_videos = null;
+                // Auto-regressive case: single new token.
+                // `rope_deltas` may be absent when generation starts from externally provided `past_key_values`.
+                // In that case, recompute from current inputs instead of relying on persisted model state.
+                if (!model_inputs.rope_deltas) {
+                    [, model_inputs.rope_deltas] = this.get_rope_index(
+                        model_inputs.input_ids,
+                        model_inputs.image_grid_thw,
+                        model_inputs.video_grid_thw,
+                        model_inputs.attention_mask,
+                    );
+                }
 
-                const delta = BigInt(Object.values(model_inputs.past_key_values)[0].dims.at(-2));
+                const delta = BigInt(past_length);
                 const rope_deltas_list = model_inputs.rope_deltas.map((x) => delta + x);
                 model_inputs.position_ids = stack([rope_deltas_list, rope_deltas_list, rope_deltas_list], 0);
             }
@@ -248,3 +343,5 @@ export class Qwen2VLForConditionalGeneration extends Qwen2VLPreTrainedModel {
         return model_inputs;
     }
 }
+
+export class Qwen2VLForCausalLM extends Qwen2VLForConditionalGeneration {}

package/src/models/qwen2_vl/processing_qwen2_vl.js

@@ -6,6 +6,7 @@ import { RawImage } from '../../utils/image.js';
 export class Qwen2VLProcessor extends Processor {
     static image_processor_class = AutoImageProcessor;
     static tokenizer_class = AutoTokenizer;
+    static image_token = '<|image_pad|>';
 
     /**
      *
@@ -31,13 +32,14 @@ export class Qwen2VLProcessor extends Processor {
             let merge_length = this.image_processor.config.merge_size ** 2;
             let index = 0;
 
+            const image_token = /** @type {typeof Qwen2VLProcessor} */ (this.constructor).image_token;
             const image_grid_thw_list = image_grid_thw.tolist();
             text = text.map((t) => {
-                while (t.includes('<|image_pad|>')) {
+                while (t.includes(image_token)) {
                     const prod = Number(image_grid_thw_list[index++].reduce((a, b) => a * b, 1n));
-                    t = t.replace('<|image_pad|>', '<|placeholder|>'.repeat(Math.floor(prod / merge_length)));
+                    t = t.replace(image_token, '<|placeholder|>'.repeat(Math.floor(prod / merge_length)));
                 }
-                return t.replaceAll('<|placeholder|>', '<|image_pad|>');
+                return t.replaceAll('<|placeholder|>', image_token);
             });
         }
 
@@ -46,7 +48,6 @@ export class Qwen2VLProcessor extends Processor {
         return {
             ...text_inputs,
             ...image_inputs,
-            // TODO: ...videos_inputs,
         };
     }
 }

package/src/models/qwen3_5/modeling_qwen3_5.js

@@ -0,0 +1,4 @@
+import { Qwen3VLForConditionalGeneration } from '../qwen3_vl/modeling_qwen3_vl.js';
+
+export class Qwen3_5ForConditionalGeneration extends Qwen3VLForConditionalGeneration {}
+export class Qwen3_5ForCausalLM extends Qwen3_5ForConditionalGeneration {}

package/src/models/qwen3_5_moe/modeling_qwen3_5_moe.js

@@ -0,0 +1,4 @@
+import { Qwen3_5ForConditionalGeneration, Qwen3_5ForCausalLM } from '../qwen3_5/modeling_qwen3_5.js';
+
+export class Qwen3_5MoeForConditionalGeneration extends Qwen3_5ForConditionalGeneration {}
+export class Qwen3_5MoeForCausalLM extends Qwen3_5ForCausalLM {}

package/src/models/qwen3_moe/modeling_qwen3_moe.js

@@ -0,0 +1,5 @@
+import { PreTrainedModel } from '../modeling_utils.js';
+
+export class Qwen3MoePreTrainedModel extends PreTrainedModel {}
+export class Qwen3MoeModel extends Qwen3MoePreTrainedModel {}
+export class Qwen3MoeForCausalLM extends Qwen3MoePreTrainedModel {}

package/src/models/qwen3_next/modeling_qwen3_next.js

@@ -0,0 +1,5 @@
+import { PreTrainedModel } from '../modeling_utils.js';
+
+export class Qwen3NextPreTrainedModel extends PreTrainedModel {}
+export class Qwen3NextModel extends Qwen3NextPreTrainedModel {}
+export class Qwen3NextForCausalLM extends Qwen3NextPreTrainedModel {}

package/src/models/qwen3_vl/modeling_qwen3_vl.js

@@ -0,0 +1,4 @@
+import { Qwen2_5_VLForConditionalGeneration, Qwen2_5_VLForCausalLM } from '../qwen2_5_vl/modeling_qwen2_5_vl.js';
+
+export class Qwen3VLForConditionalGeneration extends Qwen2_5_VLForConditionalGeneration {}
+export class Qwen3VLForCausalLM extends Qwen2_5_VLForCausalLM {}

package/src/models/qwen3_vl/processing_qwen3_vl.js

@@ -0,0 +1,3 @@
+import { Qwen2_5_VLProcessor } from '../qwen2_5_vl/processing_qwen2_5_vl.js';
+
+export class Qwen3VLProcessor extends Qwen2_5_VLProcessor {}

package/src/models/qwen3_vl_moe/modeling_qwen3_vl_moe.js

@@ -0,0 +1,4 @@
+import { Qwen3VLForConditionalGeneration, Qwen3VLForCausalLM } from '../qwen3_vl/modeling_qwen3_vl.js';
+
+export class Qwen3VLMoeForConditionalGeneration extends Qwen3VLForConditionalGeneration {}
+export class Qwen3VLMoeForCausalLM extends Qwen3VLForCausalLM {}