[Bug] Qwen-VL patch bypasses SGLang token-ID preservation and breaks multi-turn TITO

input_ids = prompt if isinstance(prompt, list) else None
prompt = self._tokenizer.decode(prompt)

caller input_ids
  -> decode to text
  -> HF processor
  -> newly tokenized input_ids

import asyncio
from difflib import SequenceMatcher

from transformers import AutoConfig, AutoProcessor

from sglang.srt.managers.schedule_batch import MultimodalInputFormat
from sglang.srt.multimodal.processors.base_processor import MultimodalSpecialTokens
from sglang.srt.multimodal.processors.qwen_vl import QwenVLImageProcessor
from sglang.srt.server_args import ServerArgs


async def main():
    model_name = "Qwen/Qwen3.6-35B-A3B"
    hf_processor = AutoProcessor.from_pretrained(model_name)
    tokenizer = hf_processor.tokenizer
    processor = QwenVLImageProcessor(
        AutoConfig.from_pretrained(model_name),
        ServerArgs(model_path=model_name),
        hf_processor,
        "default",
        skip_mm_pool=True,
    )
    # Turn 1 prompt, including one image placeholder.
    prompt_ids = tokenizer.encode(
        "<|im_start|>user\nWhat is shown?"
        "<|vision_start|><|image_pad|><|im_end|>\n"
        "<|im_start|>assistant\n",
        add_special_tokens=False,
    )

    # Turn 1 response exactly as generated by SGLang, including the assistant
    # turn terminator. Each ID is annotated with its token and decoded text:
    response_ids = [
        479,     # token "Ġtr", decoded fragment " tr"
        3770,    # token "uly", decoded fragment "uly"
        248046,  # token "<|im_end|>", decoded assistant-turn terminator
    ]

    # Turn 2 starts after the complete response above.
    next_prompt_ids = tokenizer.encode(
        "\n<|im_start|>user\nExplain your answer.<|im_end|>\n"
        "<|im_start|>assistant\n",
        add_special_tokens=False,
    )
    accumulated_ids = prompt_ids + response_ids + next_prompt_ids

    tokens = MultimodalSpecialTokens(
        image_token="<|image_pad|>",
        image_token_id=tokenizer.convert_tokens_to_ids("<|image_pad|>"),
    )
    tokens.parse_regex()
    # Valid preprocessed input keeps this loader comparison CPU-only.
    image_data = [{"format": MultimodalInputFormat.PROCESSOR_OUTPUT}]
    try:
        normal = await processor.load_mm_data(
            prompt=accumulated_ids,
            multimodal_tokens=tokens,
            image_data=image_data,
        )
        legacy = await processor.legacy_load_mm_data(
            prompt=accumulated_ids,
            multimodal_tokens=tokens,
            image_data=image_data,
        )
        _, normal_ids, _ = processor.process_and_combine_mm_data(normal, tokens)
        _, legacy_ids, _ = processor.process_and_combine_mm_data(legacy, tokens)
    finally:
        processor.io_executor.shutdown()
        processor.cpu_executor.shutdown()

    normal_ids = normal_ids.tolist()
    legacy_ids = legacy_ids.tolist()
    print("response tokens:")
    for index, token_id in enumerate(response_ids):
        print(
            f"  {index}: id={token_id}, "
            f"token={tokenizer.convert_ids_to_tokens(token_id)!r}, "
            f"text={tokenizer.decode([token_id])!r}"
        )
    print("load_mm_data preserved caller IDs:", normal.input_ids == accumulated_ids)
    print("legacy_load_mm_data input_ids:", legacy.input_ids)
    print("normal final IDs preserved caller IDs:", normal_ids == accumulated_ids)
    print(
        "legacy decoded text matches caller:",
        legacy.input_text == tokenizer.decode(accumulated_ids),
    )

    differences = []
    for tag, caller_start, caller_end, legacy_start, legacy_end in SequenceMatcher(
        a=accumulated_ids, b=legacy_ids, autojunk=False
    ).get_opcodes():
        if tag == "equal":
            continue
        caller_span = accumulated_ids[caller_start:caller_end]
        legacy_span = legacy_ids[legacy_start:legacy_end]
        differences.append((tag, caller_span, legacy_span))
        print(f"{tag}:")
        print(
            f"  caller/load_mm_data[{caller_start}:{caller_end}]",
            list(zip(caller_span, tokenizer.convert_ids_to_tokens(caller_span))),
        )
        print(
            f"  legacy retokenized[{legacy_start}:{legacy_end}]",
            list(zip(legacy_span, tokenizer.convert_ids_to_tokens(legacy_span))),
        )

    assert normal.input_ids == accumulated_ids
    assert legacy.input_ids is None
    assert normal_ids == accumulated_ids
    # Expected: the prior response's two IDs become one ID after retokenization.
    assert differences == [("replace", [479, 3770], [9149])]


asyncio.run(main())

response tokens:
  0: id=479, token='Ġtr', text=' tr'
  1: id=3770, token='uly', text='uly'
  2: id=248046, token='<|im_end|>', text='<|im_end|>'
load_mm_data preserved caller IDs: True
legacy_load_mm_data input_ids: None
normal final IDs preserved caller IDs: True
legacy decoded text matches caller: True
replace:
  caller/load_mm_data[14:16] [(479, 'Ġtr'), (3770, 'uly')]
  legacy retokenized[14:15] [(9149, 'Ġtruly')]

[350, 3140] ["ĠT", "CL"]       -> [65231] ["ĠTCL"]
[1760, 529] ["Ġcount", "ert"] -> [60110] ["Ġcountert"]
[1841, 424] ["Ġsign", "age"]  -> [79080] ["Ġsignage"]