diff --git a/test/registered/unit/parser/test_code_completion_parser.py b/test/registered/unit/parser/test_code_completion_parser.py
new file mode 100644
index 000000000..50ca71519
--- /dev/null
+++ b/test/registered/unit/parser/test_code_completion_parser.py
@@ -0,0 +1,188 @@
+"""Unit tests for srt/parser/code_completion_parser.py"""
+
+import unittest
+from unittest.mock import patch
+
+from sglang.srt.entrypoints.openai.protocol import CompletionRequest
+from sglang.srt.parser.code_completion_parser import (
+    CompletionTemplate,
+    FimPosition,
+    completion_template_exists,
+    completion_templates,
+    generate_completion_prompt,
+    generate_completion_prompt_from_request,
+    is_completion_template_defined,
+    register_completion_template,
+    set_completion_template,
+)
+from sglang.test.ci.ci_register import register_cpu_ci
+from sglang.test.test_utils import CustomTestCase
+
+register_cpu_ci(est_time=5, suite="stage-a-cpu-only")
+
+
+class TestFimPosition(CustomTestCase):
+    def test_middle_and_end_are_distinct(self):
+        """Test that MIDDLE and END are different enum values."""
+        self.assertNotEqual(FimPosition.MIDDLE, FimPosition.END)
+
+
+class TestCompletionTemplate(CustomTestCase):
+    def test_dataclass_fields(self):
+        """Test creating a CompletionTemplate with all fields."""
+        t = CompletionTemplate(
+            name="test",
+            fim_begin_token="<begin>",
+            fim_middle_token="<middle>",
+            fim_end_token="<end>",
+            fim_position=FimPosition.MIDDLE,
+        )
+        self.assertEqual(t.name, "test")
+        self.assertEqual(t.fim_begin_token, "<begin>")
+        self.assertEqual(t.fim_position, FimPosition.MIDDLE)
+
+
+class TestRegisterCompletionTemplate(CustomTestCase):
+    def test_builtin_templates_registered(self):
+        """Test that deepseek_coder, star_coder, qwen_coder are pre-registered."""
+        self.assertTrue(completion_template_exists("deepseek_coder"))
+        self.assertTrue(completion_template_exists("star_coder"))
+        self.assertTrue(completion_template_exists("qwen_coder"))
+
+    def test_unregistered_template_not_found(self):
+        """Test that a non-existent template returns False."""
+        self.assertFalse(completion_template_exists("nonexistent_template"))
+
+    def test_register_new_template(self):
+        """Test registering a new template."""
+        t = CompletionTemplate(
+            name="_test_new_template",
+            fim_begin_token="<b>",
+            fim_middle_token="<m>",
+            fim_end_token="<e>",
+            fim_position=FimPosition.END,
+        )
+        register_completion_template(t)
+        self.assertTrue(completion_template_exists("_test_new_template"))
+        # Cleanup
+        del completion_templates["_test_new_template"]
+
+    def test_register_duplicate_raises(self):
+        """Test that registering a duplicate name without override raises."""
+        with self.assertRaises(AssertionError):
+            register_completion_template(
+                CompletionTemplate(
+                    name="deepseek_coder",
+                    fim_begin_token="x",
+                    fim_middle_token="y",
+                    fim_end_token="z",
+                    fim_position=FimPosition.MIDDLE,
+                )
+            )
+
+    def test_register_duplicate_with_override(self):
+        """Test that override=True allows re-registration."""
+        original = completion_templates["deepseek_coder"]
+        try:
+            register_completion_template(
+                CompletionTemplate(
+                    name="deepseek_coder",
+                    fim_begin_token="<new>",
+                    fim_middle_token="<new_m>",
+                    fim_end_token="<new_e>",
+                    fim_position=FimPosition.END,
+                ),
+                override=True,
+            )
+            self.assertEqual(
+                completion_templates["deepseek_coder"].fim_begin_token, "<new>"
+            )
+        finally:
+            # Restore original
+            completion_templates["deepseek_coder"] = original
+
+
+class TestGenerateCompletionPrompt(CustomTestCase):
+    def test_deepseek_coder_middle_position(self):
+        """Test FIM prompt with MIDDLE position (deepseek_coder style)."""
+        result = generate_completion_prompt(
+            "prefix_code", "suffix_code", "deepseek_coder"
+        )
+        t = completion_templates["deepseek_coder"]
+        expected = f"{t.fim_begin_token}prefix_code{t.fim_middle_token}suffix_code{t.fim_end_token}"
+        self.assertEqual(result, expected)
+
+    def test_star_coder_end_position(self):
+        """Test FIM prompt with END position (star_coder style)."""
+        result = generate_completion_prompt("prefix_code", "suffix_code", "star_coder")
+        t = completion_templates["star_coder"]
+        expected = f"{t.fim_begin_token}prefix_code{t.fim_end_token}suffix_code{t.fim_middle_token}"
+        self.assertEqual(result, expected)
+
+    def test_qwen_coder_end_position(self):
+        """Test FIM prompt with END position (qwen_coder style)."""
+        result = generate_completion_prompt("prefix", "suffix", "qwen_coder")
+        t = completion_templates["qwen_coder"]
+        expected = (
+            f"{t.fim_begin_token}prefix{t.fim_end_token}suffix{t.fim_middle_token}"
+        )
+        self.assertEqual(result, expected)
+
+    def test_empty_prompt_and_suffix(self):
+        """Test FIM prompt generation with empty strings."""
+        result = generate_completion_prompt("", "", "deepseek_coder")
+        t = completion_templates["deepseek_coder"]
+        expected = f"{t.fim_begin_token}{t.fim_middle_token}{t.fim_end_token}"
+        self.assertEqual(result, expected)
+
+
+class TestGenerateCompletionPromptFromRequest(CustomTestCase):
+    def test_empty_suffix_returns_prompt_directly(self):
+        """Test that empty suffix bypasses FIM formatting."""
+        request = CompletionRequest(prompt="just code", suffix="")
+        result = generate_completion_prompt_from_request(request)
+        self.assertEqual(result, "just code")
+
+    def test_nonempty_suffix_uses_fim_template(self):
+        """Test that non-empty suffix triggers FIM formatting."""
+        with patch(
+            "sglang.srt.parser.code_completion_parser.completion_template_name",
+            "deepseek_coder",
+        ):
+            request = CompletionRequest(prompt="prefix", suffix="suffix")
+            result = generate_completion_prompt_from_request(request)
+            t = completion_templates["deepseek_coder"]
+            expected = (
+                f"{t.fim_begin_token}prefix{t.fim_middle_token}suffix{t.fim_end_token}"
+            )
+            self.assertEqual(result, expected)
+
+
+class TestSetCompletionTemplate(CustomTestCase):
+    def test_set_only_once(self):
+        """Test that set_completion_template only sets the name once."""
+        import sglang.srt.parser.code_completion_parser as module
+
+        with patch.object(module, "completion_template_name", None):
+            set_completion_template("star_coder")
+            self.assertEqual(module.completion_template_name, "star_coder")
+            # Second call should be ignored
+            set_completion_template("qwen_coder")
+            self.assertEqual(module.completion_template_name, "star_coder")
+
+    def test_is_completion_template_defined(self):
+        """Test the defined check before and after setting."""
+        import sglang.srt.parser.code_completion_parser as module
+
+        old_name = module.completion_template_name
+        try:
+            module.completion_template_name = None
+            self.assertFalse(is_completion_template_defined())
+            set_completion_template("deepseek_coder")
+            self.assertTrue(is_completion_template_defined())
+        finally:
+            module.completion_template_name = old_name
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/registered/unit/parser/test_conversation.py b/test/registered/unit/parser/test_conversation.py
new file mode 100644
index 000000000..5c3f4818e
--- /dev/null
+++ b/test/registered/unit/parser/test_conversation.py
@@ -0,0 +1,1300 @@
+"""Unit tests for srt/parser/conversation.py"""
+
+import json
+import os
+import tempfile
+import unittest
+
+from sglang.srt.entrypoints.openai.protocol import (
+    ChatCompletionMessageContentAudioPart,
+    ChatCompletionMessageContentAudioURL,
+    ChatCompletionMessageContentImagePart,
+    ChatCompletionMessageContentImageURL,
+    ChatCompletionMessageContentTextPart,
+    ChatCompletionMessageContentVideoPart,
+    ChatCompletionMessageContentVideoURL,
+    ChatCompletionMessageGenericParam,
+    ChatCompletionMessageUserParam,
+    ChatCompletionRequest,
+)
+from sglang.srt.parser.conversation import (
+    Conversation,
+    SeparatorStyle,
+    _get_full_multimodal_text_prompt,
+    chat_template_exists,
+    chat_templates,
+    generate_chat_conv,
+    generate_embedding_convs,
+    get_conv_template_by_model_path,
+    get_model_type,
+    register_conv_template,
+)
+from sglang.test.ci.ci_register import register_cpu_ci
+from sglang.test.test_utils import CustomTestCase
+
+register_cpu_ci(est_time=5, suite="stage-a-cpu-only")
+
+
+class TestConversationGetPrompt(CustomTestCase):
+    def test_add_colon_single(self):
+        """Test prompt generation with ADD_COLON_SINGLE style."""
+        conv = Conversation(
+            name="test",
+            system_message="System msg",
+            roles=("User", "Assistant"),
+            messages=[["User", "Hello"], ["Assistant", "Hi"], ["User", None]],
+            sep_style=SeparatorStyle.ADD_COLON_SINGLE,
+            sep="\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("System msg\n", prompt)
+        self.assertIn("User: Hello\n", prompt)
+        self.assertIn("Assistant: Hi\n", prompt)
+        self.assertTrue(prompt.endswith("User:"))
+
+    def test_add_colon_two(self):
+        """Test prompt generation with ADD_COLON_TWO style (alternating separators)."""
+        conv = Conversation(
+            name="test",
+            system_message="Sys",
+            roles=("User", "Assistant"),
+            messages=[["User", "Q"], ["Assistant", "A"], ["User", None]],
+            sep_style=SeparatorStyle.ADD_COLON_TWO,
+            sep="<s1>",
+            sep2="<s2>",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("User: Q<s1>", prompt)
+        self.assertIn("Assistant: A<s2>", prompt)
+        self.assertTrue(prompt.endswith("User:"))
+
+    def test_chatml(self):
+        """Test prompt generation with CHATML style."""
+        conv = Conversation(
+            name="test",
+            system_message="<|im_start|>system\nYou are helpful",
+            roles=("<|im_start|>user", "<|im_start|>assistant"),
+            messages=[
+                ["<|im_start|>user", "Hello"],
+                ["<|im_start|>assistant", None],
+            ],
+            sep_style=SeparatorStyle.CHATML,
+            sep="<|im_end|>",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("You are helpful<|im_end|>", prompt)
+        self.assertIn("<|im_start|>user\nHello<|im_end|>", prompt)
+        self.assertTrue(prompt.endswith("<|im_start|>assistant\n"))
+
+    def test_llama3(self):
+        """Test prompt generation with LLAMA3 style."""
+        conv = Conversation(
+            name="test",
+            system_message="<|start_header_id|>system<|end_header_id|>\n\nBe helpful<|eot_id|>",
+            roles=("user", "assistant"),
+            messages=[["user", "Hi"], ["assistant", None]],
+            sep_style=SeparatorStyle.LLAMA3,
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("Be helpful<|eot_id|>", prompt)
+        self.assertIn(
+            "<|start_header_id|>user<|end_header_id|>\n\nHi<|eot_id|>", prompt
+        )
+        self.assertTrue(
+            prompt.endswith("<|start_header_id|>assistant<|end_header_id|>\n\n")
+        )
+
+    def test_no_colon_single(self):
+        """Test prompt generation with NO_COLON_SINGLE style."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("[USER]", "[ASST]"),
+            messages=[["[USER]", "Hello"], ["[ASST]", None]],
+            sep_style=SeparatorStyle.NO_COLON_SINGLE,
+            sep="\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("[USER]Hello\n", prompt)
+        self.assertTrue(prompt.endswith("[ASST]"))
+
+    def test_none_message_in_prompt(self):
+        """Test that None message produces role-only output (no content)."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("User", "Assistant"),
+            messages=[["User", "Q"], ["Assistant", None]],
+            sep_style=SeparatorStyle.ADD_COLON_SINGLE,
+            sep="\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertTrue(prompt.endswith("Assistant:"))
+
+    def test_empty_system_message(self):
+        """Test that empty system message produces empty prefix for LLAMA3."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("User", "Assistant"),
+            messages=[["User", "Hello"], ["Assistant", None]],
+            sep_style=SeparatorStyle.LLAMA3,
+        )
+        prompt = conv.get_prompt()
+        self.assertNotIn("system", prompt.lower())
+
+    def test_add_colon_space_single(self):
+        """Test prompt generation with ADD_COLON_SPACE_SINGLE style."""
+        conv = Conversation(
+            name="test",
+            system_message="Sys",
+            roles=("User", "Bot"),
+            messages=[["User", "Hi"], ["Bot", None]],
+            sep_style=SeparatorStyle.ADD_COLON_SPACE_SINGLE,
+            sep="\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("User: Hi\n", prompt)
+        # None message should end with ": " (space after colon)
+        self.assertTrue(prompt.endswith("Bot: "))
+
+    def test_add_new_line_single(self):
+        """Test prompt generation with ADD_NEW_LINE_SINGLE style."""
+        conv = Conversation(
+            name="test",
+            system_message="Sys",
+            roles=("User", "Bot"),
+            messages=[["User", "Hi"], ["Bot", None]],
+            sep_style=SeparatorStyle.ADD_NEW_LINE_SINGLE,
+            sep="\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("User\nHi\n", prompt)
+        self.assertTrue(prompt.endswith("Bot\n"))
+
+    def test_no_colon_two(self):
+        """Test prompt generation with NO_COLON_TWO style (alternating separators)."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("[U]", "[A]"),
+            messages=[["[U]", "Q"], ["[A]", "A"], ["[U]", None]],
+            sep_style=SeparatorStyle.NO_COLON_TWO,
+            sep="<s1>",
+            sep2="<s2>",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("[U]Q<s1>", prompt)
+        self.assertIn("[A]A<s2>", prompt)
+        self.assertTrue(prompt.endswith("[U]"))
+
+    def test_llama2_with_system(self):
+        """Test LLAMA2 with system message."""
+        conv = Conversation(
+            name="test",
+            system_message="<<SYS>>\nBe helpful\n<</SYS>>\n\n",
+            system_template="[INST] {system_message}",
+            roles=("[INST]", "[/INST]"),
+            messages=[["[INST]", "Hi"], ["[/INST]", None]],
+            sep_style=SeparatorStyle.LLAMA2,
+            sep=" ",
+            sep2=" </s><s>",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("Be helpful", prompt)
+        self.assertIn("Hi ", prompt)
+
+    def test_llama2_without_system(self):
+        """Test LLAMA2 without system message falls back to '[INST] ' prefix."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("[INST]", "[/INST]"),
+            messages=[["[INST]", "Hi"], ["[/INST]", None]],
+            sep_style=SeparatorStyle.LLAMA2,
+            sep=" ",
+            sep2=" </s><s>",
+        )
+        prompt = conv.get_prompt()
+        self.assertTrue(prompt.startswith("[INST] Hi"))
+
+    def test_llama2_multi_turn(self):
+        """Test LLAMA2 with multi-turn (i>0 uses tag+sep pattern)."""
+        conv = Conversation(
+            name="test",
+            system_message="<<SYS>>\nSys\n<</SYS>>\n\n",
+            system_template="[INST] {system_message}",
+            roles=("[INST]", "[/INST]"),
+            messages=[
+                ["[INST]", "Q1"],
+                ["[/INST]", "A1"],
+                ["[INST]", "Q2"],
+                ["[/INST]", None],
+            ],
+            sep_style=SeparatorStyle.LLAMA2,
+            sep=" ",
+            sep2=" </s><s>",
+        )
+        prompt = conv.get_prompt()
+        # i=0: message + " " (no tag prefix)
+        self.assertIn("Q1 ", prompt)
+        # i=1: tag + " " + message + sep2
+        self.assertIn("[/INST] A1 </s><s>", prompt)
+
+    def test_llama4(self):
+        """Test prompt generation with LLAMA4 style."""
+        conv = Conversation(
+            name="test",
+            system_message="Be helpful",
+            system_template="{system_message}",
+            roles=("user", "assistant"),
+            messages=[["user", "Hello"], ["assistant", None]],
+            sep_style=SeparatorStyle.LLAMA4,
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("Be helpful", prompt)
+        self.assertIn("<|header_start|>user<|header_end|>", prompt)
+        self.assertIn("Hello<|eot|>", prompt)
+
+    def test_llama4_empty_system(self):
+        """Test LLAMA4 with empty system message omits system prefix."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("user", "assistant"),
+            messages=[["user", "Hello"], ["assistant", None]],
+            sep_style=SeparatorStyle.LLAMA4,
+        )
+        prompt = conv.get_prompt()
+        self.assertTrue(prompt.startswith("<|header_start|>user"))
+
+    def test_chatglm3(self):
+        """Test prompt generation with CHATGLM3 style."""
+        conv = Conversation(
+            name="test",
+            system_message="<|system|>\nBe helpful",
+            roles=("<|user|>", "<|assistant|>"),
+            messages=[["<|user|>", "Hi"], ["<|assistant|>", None]],
+            sep_style=SeparatorStyle.CHATGLM3,
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("Be helpful", prompt)
+        self.assertIn("<|user|>\nHi", prompt)
+        self.assertTrue(prompt.endswith("<|assistant|>"))
+
+    def test_deepseek_chat(self):
+        """Test prompt generation with DEEPSEEK_CHAT style."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("User", "Assistant"),
+            messages=[["User", "Q"], ["Assistant", "A"], ["User", None]],
+            sep_style=SeparatorStyle.DEEPSEEK_CHAT,
+            sep="\n\n",
+            sep2="<end>",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("User: Q\n\n", prompt)
+        self.assertIn("Assistant: A<end>", prompt)
+        self.assertTrue(prompt.endswith("User:"))
+
+    def test_robin(self):
+        """Test prompt generation with ROBIN style."""
+        conv = Conversation(
+            name="test",
+            system_message="Sys",
+            roles=("###Human", "###Assistant"),
+            messages=[["###Human", "Hi"], ["###Assistant", None]],
+            sep_style=SeparatorStyle.ROBIN,
+            sep="\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("###Human:\nHi\n", prompt)
+        self.assertTrue(prompt.endswith("###Assistant:\n"))
+
+    def test_falcon_chat(self):
+        """Test prompt generation with FALCON_CHAT style."""
+        conv = Conversation(
+            name="test",
+            system_message="System prompt.",
+            roles=("User", "Falcon"),
+            messages=[["User", "Hi"], ["Falcon", None]],
+            sep_style=SeparatorStyle.FALCON_CHAT,
+            sep="\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("System prompt.\n", prompt)
+        self.assertIn("User: Hi\n", prompt)
+        self.assertTrue(prompt.endswith("Falcon:"))
+
+    def test_metamath(self):
+        """Test prompt generation with METAMATH style."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("Query", "Response"),
+            messages=[["Query", "2+2?"], ["Response", None]],
+            sep_style=SeparatorStyle.METAMATH,
+            sep="\n",
+            sep2="Let's think step by step.\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("Query:\n2+2?\n", prompt)
+        self.assertIn("Response: Let's think step by step.\n", prompt)
+
+    def test_mpt(self):
+        """Test prompt generation with MPT style."""
+        conv = Conversation(
+            name="test",
+            system_message="<|system|>",
+            roles=("<|user|>", "<|assistant|>"),
+            messages=[["<|user|>", "Hi"], ["<|assistant|>", None]],
+            sep_style=SeparatorStyle.MPT,
+            sep="\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("<|user|>Hi\n", prompt)
+        self.assertTrue(prompt.endswith("<|assistant|>"))
+
+    def test_chatintern(self):
+        """Test prompt generation with CHATINTERN style."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("HUMAN", "BOT"),
+            messages=[["HUMAN", "Hi"], ["BOT", "Hello"], ["HUMAN", None]],
+            sep_style=SeparatorStyle.CHATINTERN,
+            sep="\n",
+            sep2="</s>",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("<s>HUMAN:Hi\n", prompt)
+        self.assertIn("BOT:Hello</s>", prompt)
+
+    def test_dolly(self):
+        """Test prompt generation with DOLLY style."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("Instruction", "Response"),
+            messages=[["Instruction", "Q"], ["Response", "A"], ["Instruction", None]],
+            sep_style=SeparatorStyle.DOLLY,
+            sep="\n\n",
+            sep2="</s>",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("Instruction:\nQ\n\n", prompt)
+        self.assertIn("Response:\nA</s>", prompt)
+        self.assertTrue(prompt.endswith("Instruction:\n"))
+
+    def test_phoenix(self):
+        """Test prompt generation with PHOENIX style."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("Human", "Phoenix"),
+            messages=[["Human", "Hi"], ["Phoenix", None]],
+            sep_style=SeparatorStyle.PHOENIX,
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("Human: <s>Hi</s>", prompt)
+        self.assertTrue(prompt.endswith("Phoenix: <s>"))
+
+    def test_deepseek_vl2(self):
+        """Test prompt generation with DeepSeekVL2 style."""
+        conv = Conversation(
+            name="test",
+            system_message="Sys",
+            roles=("User", "Assistant"),
+            messages=[["User", "Q"], ["Assistant", None]],
+            sep_style=SeparatorStyle.DeepSeekVL2,
+            sep="\n",
+            sep2="<end>",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("Sys\n", prompt)
+        self.assertIn("User: Q\n", prompt)
+        self.assertTrue(prompt.endswith("Assistant:"))
+
+    def test_deepseek_vl2_empty_system(self):
+        """Test DeepSeekVL2 with empty system message omits system prefix."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("User", "Assistant"),
+            messages=[["User", "Q"], ["Assistant", None]],
+            sep_style=SeparatorStyle.DeepSeekVL2,
+            sep="\n",
+            sep2="<end>",
+        )
+        prompt = conv.get_prompt()
+        self.assertTrue(prompt.startswith("User: Q"))
+
+    def test_gemma3(self):
+        """Test prompt generation with GEMMA3 style (first message special)."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("<start>", "<model>"),
+            messages=[["<start>", "Hello"], ["<model>", "Hi"], ["<start>", None]],
+            sep_style=SeparatorStyle.GEMMA3,
+            sep="<end>",
+        )
+        prompt = conv.get_prompt()
+        # First message: no role prefix, just message + sep
+        self.assertTrue(prompt.startswith("Hello<end>"))
+        # Subsequent: role + message + sep
+        self.assertIn("<model>Hi<end>", prompt)
+
+    def test_rwkv(self):
+        """Test prompt generation with RWKV style (newline replacement)."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("Bob", "Alice"),
+            messages=[["Bob", "Hello\n\nWorld"], ["Alice", None]],
+            sep_style=SeparatorStyle.RWKV,
+        )
+        prompt = conv.get_prompt()
+        # RWKV replaces \n\n with \n in message
+        self.assertIn("Bob: Hello\nWorld\n\n", prompt)
+
+    def test_qwen2_vl_embed(self):
+        """Test prompt generation with QWEN2_VL_EMBED style."""
+        conv = Conversation(
+            name="test",
+            system_message="Sys",
+            roles=("user", "assistant"),
+            messages=[["user", "Hi"], ["assistant", None]],
+            sep_style=SeparatorStyle.QWEN2_VL_EMBED,
+            sep="\n",
+            stop_str="<|endoftext|>",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("user\nHi\n", prompt)
+        self.assertTrue(prompt.endswith("<|endoftext|>"))
+
+    def test_chatglm(self):
+        """Test prompt generation with CHATGLM style (round numbering)."""
+        conv = Conversation(
+            name="chatglm",
+            system_message="",
+            roles=("问", "答"),
+            messages=[["问", "Hello"], ["答", "Hi"], ["问", None]],
+            sep_style=SeparatorStyle.CHATGLM,
+            sep="\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("[Round 0]\n", prompt)
+        self.assertIn("问：Hello\n", prompt)
+        self.assertIn("答：Hi\n", prompt)
+        self.assertTrue(prompt.endswith("问："))
+
+    def test_chatglm2_round_offset(self):
+        """Test CHATGLM style with chatglm2 name (round starts at 1 instead of 0)."""
+        conv = Conversation(
+            name="chatglm2",
+            system_message="",
+            roles=("问", "答"),
+            messages=[["问", "Hello"], ["答", None]],
+            sep_style=SeparatorStyle.CHATGLM,
+            sep="\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("[Round 1]\n", prompt)
+
+    def test_chatglm_with_system(self):
+        """Test CHATGLM with non-empty system message."""
+        conv = Conversation(
+            name="chatglm",
+            system_message="You are helpful",
+            roles=("问", "答"),
+            messages=[["问", "Hi"], ["答", None]],
+            sep_style=SeparatorStyle.CHATGLM,
+            sep="\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertTrue(prompt.startswith("You are helpful\n"))
+
+    def test_qwen2_audio(self):
+        """Test QWEN2_AUDIO style with audio token counter replacement."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("user", "assistant"),
+            messages=[
+                ["user", "Listen: <audio>{idx}</audio> and <audio>{idx}</audio>"],
+                ["assistant", None],
+            ],
+            sep_style=SeparatorStyle.QWEN2_AUDIO,
+            sep="\n",
+            audio_token="<audio>{idx}</audio>",
+        )
+        prompt = conv.get_prompt()
+        # Audio tokens should be replaced with counter: idx=1, idx=2
+        self.assertIn("<audio>1</audio>", prompt)
+        self.assertIn("<audio>2</audio>", prompt)
+        self.assertNotIn("{idx}", prompt)
+
+    def test_paddle_ocr(self):
+        """Test prompt generation with PADDLE_OCR style."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("USER", "ASSISTANT"),
+            messages=[["USER", "Describe image"], ["ASSISTANT", None]],
+            sep_style=SeparatorStyle.PADDLE_OCR,
+            sep="<eos>",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("USER: Describe image", prompt)
+        self.assertTrue(prompt.endswith("ASSISTANT: "))
+
+    def test_paddle_ocr_with_image_token(self):
+        """Test PADDLE_OCR strips newline after image token for USER role."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("USER", "ASSISTANT"),
+            messages=[
+                ["USER", "<image>\nDescribe this"],
+                ["ASSISTANT", "It shows a cat"],
+            ],
+            sep_style=SeparatorStyle.PADDLE_OCR,
+            sep="<eos>",
+            image_token="<image>",
+        )
+        prompt = conv.get_prompt()
+        # image_token + "\n" should be replaced with just image_token
+        self.assertIn("USER: <image>Describe this\n", prompt)
+        self.assertIn("ASSISTANT: It shows a cat<eos>", prompt)
+
+    def test_mpt_with_tuple_message(self):
+        """Test MPT style extracts first element from tuple messages."""
+        conv = Conversation(
+            name="test",
+            system_message="<|system|>",
+            roles=("<|user|>", "<|assistant|>"),
+            messages=[
+                ["<|user|>", ("Hello", "extra1", "extra2")],
+                ["<|assistant|>", None],
+            ],
+            sep_style=SeparatorStyle.MPT,
+            sep="\n",
+        )
+        prompt = conv.get_prompt()
+        self.assertIn("<|user|>Hello\n", prompt)
+        self.assertNotIn("extra1", prompt)
+
+    def test_invalid_sep_style_raises(self):
+        """Test that an invalid SeparatorStyle raises ValueError."""
+        conv = Conversation(
+            name="test",
+            system_message="",
+            roles=("A", "B"),
+            messages=[["A", "Hi"]],
+            sep_style=999,
+            sep="\n",
+        )
+        with self.assertRaises(ValueError):
+            conv.get_prompt()
+
+
+class TestConversationMethods(CustomTestCase):
+    def _make_conv(self):
+        return Conversation(
+            name="test",
+            roles=("User", "Assistant"),
+            messages=[],
+            sep_style=SeparatorStyle.ADD_COLON_SINGLE,
+            sep="\n",
+        )
+
+    def test_append_message(self):
+        """Test appending messages to conversation."""
+        conv = self._make_conv()
+        conv.append_message("User", "Hello")
+        conv.append_message("Assistant", "Hi")
+        self.assertEqual(len(conv.messages), 2)
+        self.assertEqual(conv.messages[0], ["User", "Hello"])
+
+    def test_set_system_message(self):
+        """Test setting the system message."""
+        conv = self._make_conv()
+        conv.set_system_message("Be helpful")
+        self.assertEqual(conv.system_message, "Be helpful")
+
+    def test_update_last_message(self):
+        """Test updating the last message in-place."""
+        conv = self._make_conv()
+        conv.append_message("User", "Q")
+        conv.append_message("Assistant", None)
+        conv.update_last_message("Answer")
+        self.assertEqual(conv.messages[-1][1], "Answer")
+
+    def test_to_openai_api_messages_with_system(self):
+        """Test conversion to OpenAI format with system message."""
+        conv = self._make_conv()
+        conv.system_message = "Be helpful"
+        conv.append_message("User", "Hello")
+        conv.append_message("Assistant", "Hi")
+        result = conv.to_openai_api_messages()
+        self.assertEqual(result[0], {"role": "system", "content": "Be helpful"})
+        self.assertEqual(result[1], {"role": "user", "content": "Hello"})
+        self.assertEqual(result[2], {"role": "assistant", "content": "Hi"})
+
+    def test_to_openai_api_messages_without_system(self):
+        """Test conversion to OpenAI format without system message."""
+        conv = self._make_conv()
+        conv.append_message("User", "Hello")
+        result = conv.to_openai_api_messages()
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]["role"], "user")
+
+    def test_to_openai_api_messages_skips_none_assistant(self):
+        """Test that None assistant message is omitted from OpenAI format."""
+        conv = self._make_conv()
+        conv.append_message("User", "Hello")
+        conv.append_message("Assistant", None)
+        result = conv.to_openai_api_messages()
+        self.assertEqual(len(result), 1)  # only user message
+
+    def test_to_gradio_chatbot(self):
+        """Test conversion to Gradio chatbot format (user/assistant pairs)."""
+        conv = self._make_conv()
+        conv.append_message("User", "Q1")
+        conv.append_message("Assistant", "A1")
+        conv.append_message("User", "Q2")
+        conv.append_message("Assistant", "A2")
+        result = conv.to_gradio_chatbot()
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result[0], ["Q1", "A1"])
+        self.assertEqual(result[1], ["Q2", "A2"])
+
+    def test_to_gradio_chatbot_pending_response(self):
+        """Test Gradio format with pending assistant response (None)."""
+        conv = self._make_conv()
+        conv.append_message("User", "Q1")
+        conv.append_message("Assistant", None)
+        result = conv.to_gradio_chatbot()
+        self.assertEqual(result, [["Q1", None]])
+
+    def test_append_image(self):
+        """Test appending image data to conversation."""
+        conv = self._make_conv()
+        conv.image_data = []
+        conv.append_image("http://example.com/img.jpg", "auto")
+        self.assertEqual(len(conv.image_data), 1)
+        self.assertEqual(conv.image_data[0].url, "http://example.com/img.jpg")
+        self.assertEqual(conv.image_data[0].detail, "auto")
+
+    def test_append_video(self):
+        """Test appending video data to conversation."""
+        conv = self._make_conv()
+        conv.video_data = []
+        conv.append_video("http://example.com/vid.mp4")
+        self.assertEqual(len(conv.video_data), 1)
+        self.assertEqual(conv.video_data[0], "http://example.com/vid.mp4")
+
+    def test_append_audio(self):
+        """Test appending audio data to conversation."""
+        conv = self._make_conv()
+        conv.audio_data = []
+        conv.append_audio("http://example.com/audio.wav")
+        self.assertEqual(len(conv.audio_data), 1)
+        self.assertEqual(conv.audio_data[0], "http://example.com/audio.wav")
+
+    def test_copy_is_independent(self):
+        """Test that copy() creates an independent conversation."""
+        conv = self._make_conv()
+        conv.append_message("User", "Hello")
+        copied = conv.copy()
+        copied.append_message("Assistant", "Hi")
+        self.assertEqual(len(conv.messages), 1)
+        self.assertEqual(len(copied.messages), 2)
+
+    def test_dict_serialization(self):
+        """Test dict() returns expected keys."""
+        conv = self._make_conv()
+        conv.append_message("User", "Hello")
+        d = conv.dict()
+        self.assertEqual(d["template_name"], "test")
+        self.assertIn("messages", d)
+        self.assertIn("roles", d)
+
+
+class TestTemplateRegistry(CustomTestCase):
+    def test_builtin_templates_exist(self):
+        """Test that common built-in templates are registered."""
+        self.assertTrue(chat_template_exists("chatml"))
+        self.assertTrue(chat_template_exists("llama-2"))
+
+    def test_unregistered_template_not_found(self):
+        """Test that non-existent template returns False."""
+        self.assertFalse(chat_template_exists("_nonexistent_template_xyz"))
+
+    def test_register_and_lookup(self):
+        """Test registering and looking up a custom template."""
+        t = Conversation(
+            name="_test_conv_template",
+            roles=("A", "B"),
+            messages=[],
+            sep_style=SeparatorStyle.ADD_COLON_SINGLE,
+            sep="\n",
+        )
+        register_conv_template(t)
+        self.assertTrue(chat_template_exists("_test_conv_template"))
+        # Cleanup
+        del chat_templates["_test_conv_template"]
+
+    def test_register_duplicate_raises(self):
+        """Test that registering a duplicate name without override raises."""
+        with self.assertRaises(AssertionError):
+            register_conv_template(
+                Conversation(
+                    name="chatml",
+                    roles=("A", "B"),
+                    messages=[],
+                    sep_style=SeparatorStyle.CHATML,
+                    sep="",
+                )
+            )
+
+    def test_get_conv_template_by_model_path_returns_none_for_unknown(self):
+        """Test that unknown model path returns None."""
+        result = get_conv_template_by_model_path("totally-unknown-model-xyz")
+        self.assertIsNone(result)
+
+    def test_get_conv_template_by_model_path_vicuna(self):
+        """Test that vicuna model path is matched correctly."""
+        result = get_conv_template_by_model_path("lmsys/vicuna-7b-v1.5")
+        self.assertEqual(result, "vicuna_v1.1")
+
+    def test_get_conv_template_by_model_path_internvl(self):
+        """Test that internvl model path is matched correctly."""
+        result = get_conv_template_by_model_path("OpenGVLab/InternVL2-8B")
+        self.assertEqual(result, "internvl-2-5")
+
+    def test_get_conv_template_by_model_path_deepseek_vl2(self):
+        """Test that deepseek-vl2 model path is matched correctly."""
+        result = get_conv_template_by_model_path("deepseek-ai/deepseek-vl2")
+        self.assertEqual(result, "deepseek-vl2")
+
+    def test_get_conv_template_by_model_path_whisper(self):
+        """Test that whisper model path is matched correctly."""
+        result = get_conv_template_by_model_path("openai/whisper-large-v3")
+        self.assertEqual(result, "whisper")
+
+    def test_get_conv_template_by_model_path_janus(self):
+        """Test that janus model path is matched correctly."""
+        result = get_conv_template_by_model_path("deepseek-ai/Janus-Pro-7B")
+        self.assertEqual(result, "janus-pro")
+
+    def test_get_conv_template_by_model_path_phi4_mm(self):
+        """Test that phi-4-multimodal model path is matched correctly."""
+        result = get_conv_template_by_model_path("microsoft/phi-4-multimodal")
+        self.assertEqual(result, "phi-4-mm")
+
+    def test_get_conv_template_by_model_path_llava_next(self):
+        """Test that llava-next-video-34b model path returns chatml-llava."""
+        result = get_conv_template_by_model_path("llava-hf/llava-next-video-34b")
+        self.assertEqual(result, "chatml-llava")
+
+    def test_get_conv_template_by_model_path_paddle_ocr(self):
+        """Test that paddleocr model path is matched correctly."""
+        result = get_conv_template_by_model_path("PaddleOCR/PaddleOCR-2.9")
+        self.assertEqual(result, "paddle-ocr")
+
+    def test_get_conv_template_by_model_path_deepseek_ocr(self):
+        """Test that deepseek-ocr model path is matched correctly."""
+        result = get_conv_template_by_model_path("deepseek-ai/deepseek-ocr-base")
+        self.assertEqual(result, "deepseek-ocr")
+
+    def test_get_conv_template_by_model_path_points(self):
+        """Test that points model path is matched correctly."""
+        result = get_conv_template_by_model_path("WePOINTS/points-v1.5")
+        self.assertEqual(result, "points-v15-chat")
+
+    def test_get_conv_template_by_model_path_minicpm_v(self):
+        """Test that minicpm-v model path returns minicpmv."""
+        result = get_conv_template_by_model_path("openbmb/MiniCPM-V-2_6")
+        self.assertEqual(result, "minicpmv")
+
+    def test_get_conv_template_by_model_path_minicpm_o(self):
+        """Test that minicpm-o model path returns minicpmo."""
+        result = get_conv_template_by_model_path("openbmb/MiniCPM-o-2_6")
+        self.assertEqual(result, "minicpmo")
+
+
+class TestGenerateEmbeddingConvs(CustomTestCase):
+    def test_text_only(self):
+        """Test generating embedding conversations with text only."""
+        convs = generate_embedding_convs(
+            texts=["Hello world"],
+            images=[None],
+            videos=[None],
+            template_name="chatml",
+        )
+        self.assertEqual(len(convs), 1)
+        self.assertEqual(len(convs[0].messages), 2)
+        self.assertIn("Hello world", convs[0].messages[0][1])
+        self.assertIsNone(convs[0].messages[1][1])  # assistant placeholder
+
+    def test_with_image(self):
+        """Test generating embedding conversations with image."""
+        convs = generate_embedding_convs(
+            texts=["Describe"],
+            images=["http://example.com/img.jpg"],
+            videos=[None],
+            template_name="chatml",
+        )
+        self.assertEqual(len(convs), 1)
+        msg = convs[0].messages[0][1]
+        self.assertIn("<image>", msg)
+        self.assertIn("Describe", msg)
+
+    def test_with_video(self):
+        """Test generating embedding conversations with video."""
+        convs = generate_embedding_convs(
+            texts=["Describe"],
+            images=[None],
+            videos=["http://example.com/vid.mp4"],
+            template_name="chatml",
+        )
+        self.assertEqual(len(convs), 1)
+        msg = convs[0].messages[0][1]
+        self.assertIn("<video>", msg)
+        self.assertIn("Describe", msg)
+
+    def test_with_image_and_video(self):
+        """Test embedding conv with both image and video."""
+        convs = generate_embedding_convs(
+            texts=["Desc"],
+            images=["http://example.com/img.jpg"],
+            videos=["http://example.com/vid.mp4"],
+            template_name="chatml",
+        )
+        msg = convs[0].messages[0][1]
+        self.assertIn("<image>", msg)
+        self.assertIn("<video>", msg)
+
+    def test_none_text(self):
+        """Test embedding conv with None text (only media)."""
+        convs = generate_embedding_convs(
+            texts=[None],
+            images=["http://example.com/img.jpg"],
+            videos=[None],
+            template_name="chatml",
+        )
+        msg = convs[0].messages[0][1]
+        self.assertIn("<image>", msg)
+        # None text should not produce "None" string
+        self.assertNotIn("None", msg)
+
+    def test_multiple_items(self):
+        """Test generating multiple embedding conversations."""
+        convs = generate_embedding_convs(
+            texts=["text1", "text2"],
+            images=[None, None],
+            videos=[None, None],
+            template_name="chatml",
+        )
+        self.assertEqual(len(convs), 2)
+
+
+class TestGetFullMultimodalTextPrompt(CustomTestCase):
+    def test_adds_missing_image_tokens(self):
+        """Test adding missing image tokens to prompt."""
+        result = _get_full_multimodal_text_prompt("<image>", 3, "Describe this.")
+        self.assertEqual(result.count("<image>"), 3)
+        self.assertIn("Describe this.", result)
+
+    def test_preserves_existing_tokens(self):
+        """Test that existing tokens in prompt are preserved."""
+        result = _get_full_multimodal_text_prompt(
+            "<image>", 2, "<image> What about this?"
+        )
+        self.assertEqual(result.count("<image>"), 2)
+
+    def test_all_tokens_present_no_addition(self):
+        """Test no addition when all tokens are already present."""
+        result = _get_full_multimodal_text_prompt("<image>", 2, "<image> and <image>")
+        self.assertEqual(result, "<image> and <image>")
+
+    def test_more_tokens_than_data_raises(self):
+        """Test that more placeholders than data items raises ValueError."""
+        with self.assertRaises(ValueError):
+            _get_full_multimodal_text_prompt("<image>", 1, "<image> <image>")
+
+    def test_zero_count_with_no_tokens(self):
+        """Test zero modality count with no tokens in prompt."""
+        result = _get_full_multimodal_text_prompt("<image>", 0, "Just text")
+        self.assertEqual(result, "Just text")
+
+    def test_video_tokens(self):
+        """Test adding missing video tokens."""
+        result = _get_full_multimodal_text_prompt("<video>", 2, "Describe:")
+        self.assertEqual(result.count("<video>"), 2)
+        self.assertIn("Describe:", result)
+
+    def test_tokens_joined_with_newline(self):
+        """Test that missing tokens are joined with newlines before prompt."""
+        result = _get_full_multimodal_text_prompt("<image>", 3, "text")
+        # 3 images, 0 in prompt → 3 added, joined by \n, then \n before text
+        lines = result.split("\n")
+        self.assertEqual(lines[0], "<image>")
+        self.assertEqual(lines[1], "<image>")
+        self.assertEqual(lines[2], "<image>")
+        self.assertEqual(lines[3], "text")
+
+
+class TestGenerateChatConv(CustomTestCase):
+    """Test generate_chat_conv with real Pydantic message objects."""
+
+    def _make_request(self, messages):
+        """Create a real ChatCompletionRequest with given messages."""
+        return ChatCompletionRequest(messages=messages, model="test")
+
+    def test_simple_user_message(self):
+        """Test basic user string message."""
+        request = self._make_request(
+            [ChatCompletionMessageUserParam(role="user", content="Hello")]
+        )
+        conv = generate_chat_conv(request, "chatml")
+        # user message + blank assistant placeholder
+        self.assertEqual(len(conv.messages), 2)
+        self.assertIn("Hello", conv.messages[0][1])
+        self.assertIsNone(conv.messages[1][1])
+
+    def test_system_then_user(self):
+        """Test system message followed by user message."""
+        request = self._make_request(
+            [
+                ChatCompletionMessageGenericParam(role="system", content="Be helpful"),
+                ChatCompletionMessageUserParam(role="user", content="Hi"),
+            ]
+        )
+        conv = generate_chat_conv(request, "chatml")
+        self.assertEqual(conv.system_message, "Be helpful")
+        self.assertIn("Hi", conv.messages[0][1])
+
+    def test_system_message_as_list(self):
+        """Test system message given as a single-element list of text parts."""
+        request = self._make_request(
+            [
+                ChatCompletionMessageGenericParam(
+                    role="system",
+                    content=[
+                        ChatCompletionMessageContentTextPart(
+                            type="text", text="System text"
+                        )
+                    ],
+                ),
+                ChatCompletionMessageUserParam(role="user", content="Hi"),
+            ]
+        )
+        conv = generate_chat_conv(request, "chatml")
+        self.assertEqual(conv.system_message, "System text")
+
+    def test_system_message_invalid_list_raises(self):
+        """Test that system message with non-text content raises ValueError."""
+        request = self._make_request(
+            [
+                ChatCompletionMessageGenericParam(
+                    role="system",
+                    content=[
+                        ChatCompletionMessageContentImagePart(
+                            type="image_url",
+                            image_url=ChatCompletionMessageContentImageURL(
+                                url="http://example.com/img.jpg"
+                            ),
+                        )
+                    ],
+                ),
+                ChatCompletionMessageUserParam(role="user", content="Hi"),
+            ]
+        )
+        with self.assertRaises(ValueError):
+            generate_chat_conv(request, "chatml")
+
+    def test_multi_turn_conversation(self):
+        """Test multi-turn user/assistant conversation."""
+        request = self._make_request(
+            [
+                ChatCompletionMessageUserParam(role="user", content="What is 2+2?"),
+                ChatCompletionMessageGenericParam(role="assistant", content="4"),
+                ChatCompletionMessageUserParam(role="user", content="And 3+3?"),
+            ]
+        )
+        conv = generate_chat_conv(request, "chatml")
+        # 3 explicit messages + 1 blank assistant placeholder
+        self.assertEqual(len(conv.messages), 4)
+        self.assertEqual(conv.messages[1][1], "4")
+        self.assertIsNone(conv.messages[3][1])
+
+    def test_assistant_message_as_list(self):
+        """Test assistant message given as a single-element list of text parts."""
+        request = self._make_request(
+            [
+                ChatCompletionMessageUserParam(role="user", content="Hi"),
+                ChatCompletionMessageGenericParam(
+                    role="assistant",
+                    content=[
+                        ChatCompletionMessageContentTextPart(type="text", text="Hello!")
+                    ],
+                ),
+                ChatCompletionMessageUserParam(role="user", content="How are you?"),
+            ]
+        )
+        conv = generate_chat_conv(request, "chatml")
+        self.assertEqual(conv.messages[1][1], "Hello!")
+
+    def test_assistant_invalid_list_raises(self):
+        """Test that assistant message with non-text content raises ValueError."""
+        request = self._make_request(
+            [
+                ChatCompletionMessageUserParam(role="user", content="Hi"),
+                ChatCompletionMessageGenericParam(
+                    role="assistant",
+                    content=[
+                        ChatCompletionMessageContentImagePart(
+                            type="image_url",
+                            image_url=ChatCompletionMessageContentImageURL(
+                                url="http://example.com/img.jpg"
+                            ),
+                        )
+                    ],
+                ),
+            ]
+        )
+        with self.assertRaises(ValueError):
+            generate_chat_conv(request, "chatml")
+
+    def test_string_messages_raises(self):
+        """Test that passing messages as a raw string raises ValueError."""
+        request = self._make_request(
+            [ChatCompletionMessageUserParam(role="user", content="Hi")]
+        )
+        # Manually override messages to be a string to trigger validation
+        request.__dict__["messages"] = "not a list"
+        with self.assertRaises(ValueError):
+            generate_chat_conv(request, "chatml")
+
+    def test_user_message_with_image(self):
+        """Test user message with image content part."""
+        request = self._make_request(
+            [
+                ChatCompletionMessageUserParam(
+                    role="user",
+                    content=[
+                        ChatCompletionMessageContentTextPart(
+                            type="text", text="What's in this image?"
+                        ),
+                        ChatCompletionMessageContentImagePart(
+                            type="image_url",
+                            image_url=ChatCompletionMessageContentImageURL(
+                                url="http://example.com/cat.jpg"
+                            ),
+                        ),
+                    ],
+                )
+            ]
+        )
+        conv = generate_chat_conv(request, "chatml")
+        self.assertEqual(len(conv.image_data), 1)
+        self.assertEqual(conv.image_data[0].url, "http://example.com/cat.jpg")
+        msg = conv.messages[0][1]
+        self.assertIn("What's in this image?", msg)
+
+    def test_user_message_with_video(self):
+        """Test user message with video content part."""
+        request = self._make_request(
+            [
+                ChatCompletionMessageUserParam(
+                    role="user",
+                    content=[
+                        ChatCompletionMessageContentTextPart(
+                            type="text", text="Describe this video"
+                        ),
+                        ChatCompletionMessageContentVideoPart(
+                            type="video_url",
+                            video_url=ChatCompletionMessageContentVideoURL(
+                                url="http://example.com/vid.mp4"
+                            ),
+                        ),
+                    ],
+                )
+            ]
+        )
+        conv = generate_chat_conv(request, "chatml")
+        self.assertEqual(len(conv.video_data), 1)
+        self.assertEqual(conv.video_data[0], "http://example.com/vid.mp4")
+
+    def test_user_message_with_audio(self):
+        """Test user message with audio content part."""
+        request = self._make_request(
+            [
+                ChatCompletionMessageUserParam(
+                    role="user",
+                    content=[
+                        ChatCompletionMessageContentTextPart(
+                            type="text", text="Transcribe this"
+                        ),
+                        ChatCompletionMessageContentAudioPart(
+                            type="audio_url",
+                            audio_url=ChatCompletionMessageContentAudioURL(
+                                url="http://example.com/audio.wav"
+                            ),
+                        ),
+                    ],
+                )
+            ]
+        )
+        conv = generate_chat_conv(request, "chatml")
+        self.assertEqual(len(conv.audio_data), 1)
+        self.assertEqual(conv.audio_data[0], "http://example.com/audio.wav")
+
+    def test_user_message_image_at_prefix(self):
+        """Test image_token_at_prefix=True puts image token before text."""
+        # Register a temporary template with image_token_at_prefix=True
+        tmp_name = "_test_prefix_img"
+        register_conv_template(
+            Conversation(
+                name=tmp_name,
+                roles=("<|im_start|>user", "<|im_start|>assistant"),
+                messages=[],
+                sep_style=SeparatorStyle.CHATML,
+                sep="<|im_end|>",
+                image_token_at_prefix=True,
+            )
+        )
+        try:
+            request = self._make_request(
+                [
+                    ChatCompletionMessageUserParam(
+                        role="user",
+                        content=[
+                            ChatCompletionMessageContentTextPart(
+                                type="text", text="Describe"
+                            ),
+                            ChatCompletionMessageContentImagePart(
+                                type="image_url",
+                                image_url=ChatCompletionMessageContentImageURL(
+                                    url="http://example.com/img.jpg"
+                                ),
+                            ),
+                        ],
+                    )
+                ]
+            )
+            conv = generate_chat_conv(request, tmp_name)
+            msg = conv.messages[0][1]
+            # Image token should be BEFORE "Describe"
+            img_pos = msg.find("<image>")
+            txt_pos = msg.find("Describe")
+            self.assertGreater(txt_pos, img_pos)
+        finally:
+            del chat_templates[tmp_name]
+
+    def test_deepseek_vl2_modality_supplement(self):
+        """Test deepseek-vl2 modality supplement (add_token_as_needed path)."""
+        request = self._make_request(
+            [
+                ChatCompletionMessageUserParam(
+                    role="user",
+                    content=[
+                        ChatCompletionMessageContentTextPart(
+                            type="text", text="Describe both"
+                        ),
+                        ChatCompletionMessageContentImagePart(
+                            type="image_url",
+                            image_url=ChatCompletionMessageContentImageURL(
+                                url="http://example.com/img1.jpg"
+                            ),
+                        ),
+                        ChatCompletionMessageContentImagePart(
+                            type="image_url",
+                            image_url=ChatCompletionMessageContentImageURL(
+                                url="http://example.com/img2.jpg"
+                            ),
+                        ),
+                    ],
+                )
+            ]
+        )
+        conv = generate_chat_conv(request, "deepseek-vl2")
+        self.assertEqual(len(conv.image_data), 2)
+        msg = conv.messages[0][1]
+        # deepseek-vl2 uses _get_full_multimodal_text_prompt to add image tokens
+        self.assertIn("Describe both", msg)
+
+    def test_unknown_role_raises(self):
+        """Test that an unknown message role raises ValueError."""
+        request = self._make_request(
+            [ChatCompletionMessageUserParam(role="user", content="Hi")]
+        )
+        # Manually inject a message with unknown role
+        from types import SimpleNamespace
+
+        request.__dict__["messages"] = [SimpleNamespace(role="alien", content="Hi")]
+        with self.assertRaises(ValueError):
+            generate_chat_conv(request, "chatml")
+
+    def test_user_message_many_images_adds_newline(self):
+        """Test that >16 images triggers newline before text content."""
+        image_parts = [
+            ChatCompletionMessageContentImagePart(
+                type="image_url",
+                image_url=ChatCompletionMessageContentImageURL(
+                    url=f"http://example.com/img{i}.jpg"
+                ),
+            )
+            for i in range(17)
+        ]
+        content = [
+            ChatCompletionMessageContentTextPart(type="text", text="Describe all")
+        ] + image_parts
+        request = self._make_request(
+            [ChatCompletionMessageUserParam(role="user", content=content)]
+        )
+        conv = generate_chat_conv(request, "chatml")
+        self.assertEqual(len(conv.image_data), 17)
+        # With >16 images, text content is prefixed with "\n"
+        self.assertIn("\nDescribe all", conv.messages[0][1])
+
+
+class TestGetModelType(CustomTestCase):
+    def test_nonexistent_path_returns_none(self):
+        """Test that a path without config.json returns None."""
+        result = get_model_type("/nonexistent/path/abc123")
+        self.assertIsNone(result)
+
+    def test_valid_config_returns_model_type(self):
+        """Test reading model_type from a real config.json file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config = {"model_type": "llama", "hidden_size": 4096}
+            with open(os.path.join(tmpdir, "config.json"), "w") as f:
+                json.dump(config, f)
+            result = get_model_type(tmpdir)
+            self.assertEqual(result, "llama")
+
+    def test_config_without_model_type_returns_none(self):
+        """Test that config.json without model_type key returns None."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config = {"hidden_size": 4096}
+            with open(os.path.join(tmpdir, "config.json"), "w") as f:
+                json.dump(config, f)
+            result = get_model_type(tmpdir)
+            self.assertIsNone(result)
+
+    def test_invalid_json_returns_none(self):
+        """Test that malformed config.json returns None (JSONDecodeError)."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with open(os.path.join(tmpdir, "config.json"), "w") as f:
+                f.write("not valid json{{{")
+            result = get_model_type(tmpdir)
+            self.assertIsNone(result)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/registered/unit/parser/test_harmony_parser.py b/test/registered/unit/parser/test_harmony_parser.py
index 9a736a64f..02c559146 100644
--- a/test/registered/unit/parser/test_harmony_parser.py
+++ b/test/registered/unit/parser/test_harmony_parser.py
@@ -1,3 +1,5 @@
+"""Unit tests for srt/parser/harmony_parser.py"""
+
 import unittest
 
 from sglang.srt.parser.harmony_parser import (
@@ -483,15 +485,12 @@ class TestHarmonyParser(CustomTestCase):
             events = self.parser.parse(chunk)
             all_events.extend(events)
 
-        self.assertEqual(len(all_events), 5)
-
-        # Verify we get reasoning events
+        # Verify we get both reasoning and normal events
         reasoning_events = [e for e in all_events if e.event_type == "reasoning"]
-        self.assertTrue(len(reasoning_events) > 0)
+        self.assertGreater(len(reasoning_events), 0)
 
-        # Verify we get normal events
         normal_events = [e for e in all_events if e.event_type == "normal"]
-        self.assertTrue(len(normal_events) > 0)
+        self.assertGreater(len(normal_events), 0)
 
         # Verify content is eventually parsed correctly
         combined_reasoning = "".join(e.content for e in reasoning_events)
@@ -875,5 +874,150 @@ class TestEdgeCases(CustomTestCase):
         self.assertEqual(events[1].content, "second reasoning")
 
 
+class TestAdditionalEdgeCases(CustomTestCase):
+    """Additional tests to cover remaining edge cases."""
+
+    def test_prefix_hold_with_empty_token_in_list(self):
+        """Test that empty string token in the list is skipped."""
+        from sglang.srt.parser.harmony_parser import prefix_hold
+
+        emit, hold = prefix_hold("hello", ["", "world"])
+        self.assertEqual(emit, "hello")
+        self.assertEqual(hold, "")
+
+    def test_iter_tokens_unknown_token_no_closing(self):
+        """Test iter_tokens with <| that has no closing |>."""
+        from sglang.srt.parser.harmony_parser import iter_tokens
+
+        tokens = list(iter_tokens("<|broken text without close", 0))
+        # Should emit TEXT tokens for the content after <|
+        self.assertTrue(any(t.type == "TEXT" for t in tokens))
+
+    def test_canonical_commentary_filler_after_call(self):
+        """Test that MESSAGE token after CALL is filtered as commentary filler."""
+        from sglang.srt.parser.harmony_parser import CanonicalStrategy
+
+        strategy = CanonicalStrategy()
+        text = "<|start|><|channel|>analysis<|message|>thinking<|end|><|call|><|message|>noise<|return|><|channel|>final<|message|>answer<|end|>"
+        events, remainder = strategy.parse(text)
+        # The MESSAGE after CALL should be filtered, final answer should appear
+        answers = [e.content for e in events if e.event_type == "normal"]
+        self.assertTrue(any("answer" in a for a in answers))
+
+    def test_canonical_standalone_structural_token_filtered(self):
+        """Test that standalone structural tokens like <|end|> in TEXT position are filtered."""
+        from sglang.srt.parser.harmony_parser import CanonicalStrategy
+
+        strategy = CanonicalStrategy()
+        # A malformed sequence where an END token appears in an unexpected position
+        text = "<|start|><|channel|>analysis<|message|>content<|end|>"
+        events, remainder = strategy.parse(text)
+        # Should parse without error
+        self.assertTrue(len(events) >= 0)
+
+    def test_canonical_incomplete_block_returns_partial(self):
+        """Test parsing an incomplete channel block (no END token)."""
+        from sglang.srt.parser.harmony_parser import CanonicalStrategy
+
+        strategy = CanonicalStrategy()
+        text = "<|start|><|channel|>analysis<|message|>partial content"
+        events, remainder = strategy.parse(text)
+        # Incomplete block: should hold content as remainder or emit partial
+        reasoning_events = [e for e in events if e.event_type == "reasoning"]
+        # The partial content may be in events or remainder
+        total = "".join(e.content for e in reasoning_events) + remainder
+        self.assertIn("partial", total)
+
+    def test_text_strategy_commentary_channel(self):
+        """Test TextStrategy parsing commentary channel."""
+        from sglang.srt.parser.harmony_parser import TextStrategy
+
+        strategy = TextStrategy()
+        text = "commentary: some discussion\nassistantfinal: the answer"
+        events, remainder = strategy.parse(text)
+        normal = [e for e in events if e.event_type == "normal"]
+        self.assertTrue(any("the answer" in e.content for e in normal))
+
+    def test_canonical_call_with_text_commentary_after(self):
+        """Test filtering of 'commentary' text after CALL token."""
+        from sglang.srt.parser.harmony_parser import CanonicalStrategy
+
+        strategy = CanonicalStrategy()
+        text = "<|start|><|channel|>analysis<|message|>think<|end|><|call|>commentary<|return|><|channel|>final<|message|>result<|end|>"
+        events, remainder = strategy.parse(text)
+        normal = [e for e in events if e.event_type == "normal"]
+        self.assertTrue(any("result" in e.content for e in normal))
+
+    def test_canonical_return_without_final(self):
+        """Test that _parse_block returns None for block without proper end."""
+        from sglang.srt.parser.harmony_parser import CanonicalStrategy
+
+        strategy = CanonicalStrategy()
+        # Channel block that has no message content before end
+        text = "<|start|><|channel|>final<|end|>"
+        events, remainder = strategy.parse(text)
+        # Should handle gracefully
+        self.assertIsInstance(events, list)
+
+    def test_iter_tokens_unknown_at_end_no_next_marker(self):
+        """Test unknown token with |> close but no next <| marker after it."""
+        from sglang.srt.parser.harmony_parser import iter_tokens
+
+        # <|weird|> is unknown, has closing |>, but nothing after it
+        tokens = list(iter_tokens("<|weird|>trailing", 0))
+        # Should emit TEXT tokens covering the content
+        all_text = "".join(
+            "<|weird|>trailing"[t.start : t.end] for t in tokens if t.type == "TEXT"
+        )
+        self.assertIn("weird|>trailing", all_text)
+
+    def test_canonical_standalone_end_token_filtered(self):
+        """Test that standalone <|end|> in TEXT position is filtered out."""
+        from sglang.srt.parser.harmony_parser import CanonicalStrategy
+
+        strategy = CanonicalStrategy()
+        # Malformed: <|end|> appears before any channel/message structure
+        text = "<|end|><|start|><|channel|>final<|message|>answer<|end|>"
+        events, remainder = strategy.parse(text)
+        # The standalone <|end|> should be filtered, answer should appear
+        normal = [e.content for e in events if e.event_type == "normal"]
+        self.assertTrue(any("answer" in c for c in normal))
+
+    def test_canonical_incomplete_parse_block_no_end(self):
+        """Test that a channel block without END/CALL/RETURN returns None (incomplete)."""
+        from sglang.srt.parser.harmony_parser import CanonicalStrategy
+
+        strategy = CanonicalStrategy()
+        # Channel with message but no end token
+        text = "<|start|><|channel|>final<|message|>partial"
+        events, remainder = strategy.parse(text)
+        # Should be treated as incomplete
+        total = "".join(e.content for e in events) + remainder
+        self.assertIn("partial", total)
+
+    def test_text_strategy_commentary_only(self):
+        """Test TextStrategy with commentary-only pattern (no 'assistantfinal')."""
+        from sglang.srt.parser.harmony_parser import TextStrategy
+
+        strategy = TextStrategy()
+        text = "commentary: just a comment here"
+        events, remainder = strategy.parse(text)
+        normal = [e for e in events if e.event_type == "normal"]
+        # Commentary content should appear as normal text
+        combined = "".join(e.content for e in normal) + remainder
+        self.assertIn("comment", combined)
+
+    def test_text_strategy_commentary_with_hold(self):
+        """Test TextStrategy commentary channel with prefix that could be 'assistantfinal'."""
+        from sglang.srt.parser.harmony_parser import TextStrategy
+
+        strategy = TextStrategy()
+        # Content ends with "assistant" which is a prefix of "assistantfinal"
+        text = "commentary: discussion assistant"
+        events, remainder = strategy.parse(text)
+        # "assistant" at end should be held back
+        self.assertIn("assistant", remainder)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/registered/unit/parser/test_jinja_template_utils.py b/test/registered/unit/parser/test_jinja_template_utils.py
index dfb6ff79c..3396de98a 100644
--- a/test/registered/unit/parser/test_jinja_template_utils.py
+++ b/test/registered/unit/parser/test_jinja_template_utils.py
@@ -1,6 +1,4 @@
-"""
-Unit tests for Jinja chat template utils.
-"""
+"""Unit tests for srt/parser/jinja_template_utils.py"""
 
 import unittest
 
@@ -308,6 +306,186 @@ class TestTemplateContentFormatDetection(CustomTestCase):
         expected_keys = {"role", "content"}
         self.assertEqual(set(result.keys()), expected_keys)
 
+    def test_process_content_with_video(self):
+        """Test content processing with video_url content."""
+        msg_dict = {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": "Watch this:"},
+                {"type": "video_url", "video_url": {"url": "http://example.com/v.mp4"}},
+            ],
+        }
+        image_data = []
+        video_data = []
+        audio_data = []
+        modalities = []
+        result = process_content_for_template_format(
+            msg_dict, "openai", image_data, video_data, audio_data, modalities
+        )
+        self.assertEqual(len(video_data), 1)
+        self.assertEqual(video_data[0], "http://example.com/v.mp4")
+        self.assertEqual(result["content"][1], {"type": "video"})
+
+    def test_process_content_video_with_max_dynamic_patch(self):
+        """Test video_url with max_dynamic_patch stores structured dict."""
+        msg_dict = {
+            "role": "user",
+            "content": [
+                {
+                    "type": "video_url",
+                    "video_url": {
+                        "url": "http://example.com/v.mp4",
+                        "max_dynamic_patch": 4,
+                    },
+                },
+            ],
+        }
+        image_data = []
+        video_data = []
+        audio_data = []
+        modalities = []
+        result = process_content_for_template_format(
+            msg_dict, "openai", image_data, video_data, audio_data, modalities
+        )
+        self.assertEqual(len(video_data), 1)
+        self.assertIsInstance(video_data[0], dict)
+        self.assertEqual(video_data[0]["max_dynamic_patch"], 4)
+
+    def test_process_content_v32_encoding(self):
+        """Test v32 encoding mode flattens text and ignores structured content parts."""
+        msg_dict = {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": "Hello"},
+                {
+                    "type": "image_url",
+                    "image_url": {"url": "http://example.com/img.jpg"},
+                },
+                {"type": "text", "text": "World"},
+            ],
+        }
+        image_data = []
+        video_data = []
+        audio_data = []
+        modalities = []
+        result = process_content_for_template_format(
+            msg_dict,
+            "openai",
+            image_data,
+            video_data,
+            audio_data,
+            modalities,
+            use_dpsk_v32_encoding=True,
+        )
+        # v32 encoding: content is joined text, not list
+        self.assertEqual(result["content"], "Hello World")
+        # Image data is still extracted
+        self.assertEqual(len(image_data), 1)
+
+    def test_process_content_invalid_format_raises(self):
+        """Test that invalid content_format raises ValueError."""
+        msg_dict = {
+            "role": "user",
+            "content": [{"type": "text", "text": "Hi"}],
+        }
+        with self.assertRaises(ValueError):
+            process_content_for_template_format(
+                msg_dict, "invalid_format", [], [], [], []
+            )
+
+    def test_process_content_video_with_modalities(self):
+        """Test that video content with modalities field is extracted."""
+        msg_dict = {
+            "role": "user",
+            "content": [
+                {
+                    "type": "video_url",
+                    "video_url": {"url": "http://example.com/v.mp4"},
+                    "modalities": ["video"],
+                },
+            ],
+        }
+        image_data = []
+        video_data = []
+        audio_data = []
+        modalities = []
+        result = process_content_for_template_format(
+            msg_dict, "openai", image_data, video_data, audio_data, modalities
+        )
+        self.assertEqual(len(modalities), 1)
+        self.assertEqual(modalities[0], ["video"])
+
+    def test_detect_template_with_filter(self):
+        """Test that content access through a Jinja filter is detected as openai."""
+        # Template with | trim filter on content iteration
+        template = """
+{%- for message in messages %}
+    {%- for content in message['content'] | trim %}
+        {{- content }}
+    {%- endfor %}
+{%- endfor %}
+        """
+        result = detect_jinja_template_content_format(template)
+        self.assertEqual(result, "openai")
+
+    def test_detect_template_with_is_test(self):
+        """Test that 'is string' test on content triggers openai detection."""
+        # Template with 'is string' test that also iterates content
+        template = """
+{%- for message in messages %}
+    {%- if message['content'] is string %}
+        {{- message['content'] }}
+    {%- else %}
+        {%- for item in message['content'] %}
+            {{- item }}
+        {%- endfor %}
+    {%- endif %}
+{%- endfor %}
+        """
+        result = detect_jinja_template_content_format(template)
+        self.assertEqual(result, "openai")
+
+    def test_detect_template_with_slice(self):
+        """Test that content access through slice is detected as openai."""
+        template = """
+{%- for message in messages %}
+    {%- for item in message['content'][:5] %}
+        {{- item }}
+    {%- endfor %}
+{%- endfor %}
+        """
+        result = detect_jinja_template_content_format(template)
+        self.assertEqual(result, "openai")
+
+    def test_detect_template_no_content_loop_is_string(self):
+        """Test that template without content iteration returns string format."""
+        template = """
+{%- for message in messages %}
+    {{- message['role'] }}: {{ message['content'] }}
+{%- endfor %}
+        """
+        # No "image"/"audio"/"video" keyword, no content loop → string
+        result = detect_jinja_template_content_format(template)
+        self.assertEqual(result, "string")
+
+    def test_detect_msg_content_without_multimodal_keywords(self):
+        """Test AST detection of 'for item in msg.content' without keyword shortcut.
+        Templates that contain 'image'/'video'/'audio'/'vision' take a shortcut.
+        This template deliberately avoids those keywords to test the AST path."""
+        template = """
+{%- for msg in messages %}
+    {%- if msg.content is string %}
+        {{- msg.content }}
+    {%- else %}
+        {%- for item in msg.content %}
+            {{- item.text }}
+        {%- endfor %}
+    {%- endif %}
+{%- endfor %}
+        """
+        result = detect_jinja_template_content_format(template)
+        self.assertEqual(result, "openai")
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/registered/unit/parser/test_reasoning_parser.py b/test/registered/unit/parser/test_reasoning_parser.py
index 607a6ca52..5b9d623d5 100644
--- a/test/registered/unit/parser/test_reasoning_parser.py
+++ b/test/registered/unit/parser/test_reasoning_parser.py
@@ -1,3 +1,5 @@
+"""Unit tests for srt/parser/reasoning_parser.py"""
+
 import unittest
 
 from sglang.srt.parser.reasoning_parser import (
@@ -483,8 +485,11 @@ class TestGlm45Detector(CustomTestCase):
         self.assertEqual(result.reasoning_text, "")
         self.assertEqual(result.normal_text, "")
 
-        # Tool interruption should still work - flushes buffered reasoning
-        # Note: buffer preserves original text including <think> tag
+        # Tool interruption should still work - flushes buffered reasoning.
+        # Note: when stream_reasoning=False, the <think> tag is stripped from the
+        # local `current_text` variable but NOT from `self._buffer` (which is never
+        # cleared in the non-streaming path). So the flushed reasoning content
+        # includes the raw <think> tag.
         result = detector.parse_streaming_increment("<tool_call>tool call")
         self.assertEqual(result.reasoning_text, "<think>thinking")
         self.assertEqual(result.normal_text, "<tool_call>tool call")
@@ -836,7 +841,7 @@ class TestBufferLossBugFix(CustomTestCase):
         5. Buffer is cleared and "answer" is returned directly
         6. The "</" from previous step is lost
 
-        This test verifies the fix where line 108 was changed from:
+        This test verifies the fix where the return was changed from:
         return StreamingParseResult(normal_text=new_text)
         to:
         return StreamingParseResult(normal_text=current_text)
@@ -933,5 +938,301 @@ class TestBufferLossBugFix(CustomTestCase):
         self.assertTrue(detector.stripped_think_start)
 
 
+class TestGptOssDetector(CustomTestCase):
+    """Test cases for GptOssDetector which delegates to HarmonyParser."""
+
+    def setUp(self):
+        from sglang.srt.parser.reasoning_parser import GptOssDetector
+
+        self.detector = GptOssDetector()
+
+    def test_detect_and_parse_with_analysis_and_final(self):
+        """Test one-shot parsing with analysis (reasoning) and final (normal) blocks."""
+        text = "<|start|><|channel|>analysis<|message|>thinking hard<|end|><|channel|>final<|message|>the answer<|end|>"
+        result = self.detector.detect_and_parse(text)
+        self.assertIn("thinking hard", result.reasoning_text)
+        self.assertIn("the answer", result.normal_text)
+
+    def test_detect_and_parse_normal_only(self):
+        """Test one-shot parsing with only final block."""
+        text = "<|start|><|channel|>final<|message|>just the answer<|end|>"
+        result = self.detector.detect_and_parse(text)
+        self.assertIn("just the answer", result.normal_text)
+
+    def test_streaming_analysis_then_final(self):
+        """Test streaming parse across multiple chunks."""
+        chunks = [
+            "<|start|><|channel|>analysis<|message|>",
+            "reasoning part",
+            "<|end|>",
+            "<|channel|>final<|message|>answer",
+            "<|end|>",
+        ]
+        all_reasoning = ""
+        all_normal = ""
+        for chunk in chunks:
+            result = self.detector.parse_streaming_increment(chunk)
+            all_reasoning += result.reasoning_text
+            all_normal += result.normal_text
+        self.assertIn("reasoning part", all_reasoning)
+        self.assertIn("answer", all_normal)
+
+    def test_streaming_with_tool_call(self):
+        """Test streaming parse with tool call events."""
+        text = "<|start|><|channel|>analysis<|message|>think<|end|><|call|>tool_data<|return|><|channel|>final<|message|>result<|end|>"
+        result = self.detector.detect_and_parse(text)
+        self.assertIn("think", result.reasoning_text)
+        self.assertIn("result", result.normal_text)
+
+
+class TestMiniMaxAppendThinkDetector(CustomTestCase):
+    """Test cases for MiniMaxAppendThinkDetector."""
+
+    def setUp(self):
+        from sglang.srt.parser.reasoning_parser import MiniMaxAppendThinkDetector
+
+        self.detector = MiniMaxAppendThinkDetector()
+
+    def test_detect_and_parse_prepends_think(self):
+        """Test that detect_and_parse prepends <think> to the text."""
+        result = self.detector.detect_and_parse("Hello world")
+        self.assertEqual(result.normal_text, "<think>Hello world")
+
+    def test_streaming_first_chunk_prepends_think(self):
+        """Test that first streaming chunk gets <think> prepended."""
+        result = self.detector.parse_streaming_increment("First chunk")
+        self.assertEqual(result.normal_text, "<think>First chunk")
+
+    def test_streaming_second_chunk_no_prepend(self):
+        """Test that subsequent streaming chunks are passed through."""
+        self.detector.parse_streaming_increment("First")
+        result = self.detector.parse_streaming_increment("Second")
+        self.assertEqual(result.normal_text, "Second")
+
+
+class TestReasoningParserAdvanced(CustomTestCase):
+    """Additional tests for ReasoningParser init edge cases."""
+
+    def test_gpt_oss_model_type(self):
+        """Test that gpt-oss model type creates GptOssDetector."""
+        from sglang.srt.parser.reasoning_parser import GptOssDetector
+
+        parser = ReasoningParser("gpt-oss")
+        self.assertIsInstance(parser.detector, GptOssDetector)
+
+    def test_minimax_append_think_model_type(self):
+        """Test that minimax-append-think creates MiniMaxAppendThinkDetector."""
+        from sglang.srt.parser.reasoning_parser import MiniMaxAppendThinkDetector
+
+        parser = ReasoningParser("minimax-append-think")
+        self.assertIsInstance(parser.detector, MiniMaxAppendThinkDetector)
+
+    def test_qwen3_thinking_forces_reasoning(self):
+        """Test that qwen3-thinking model type forces reasoning mode."""
+        parser = ReasoningParser("qwen3-thinking")
+        self.assertTrue(parser.detector._in_reasoning)
+
+    def test_minimax_forces_reasoning(self):
+        """Test that minimax model type forces reasoning mode.
+
+        minimax maps to Qwen3Detector but ReasoningParser overrides
+        force_reasoning=True, unlike the default Qwen3Detector behavior.
+        """
+        parser = ReasoningParser("minimax")
+        self.assertIsInstance(parser.detector, Qwen3Detector)
+        self.assertTrue(parser.detector._in_reasoning)
+
+    def test_detector_map_aliases(self):
+        """Test that all DetectorMap alias keys create the correct detector type."""
+        # These are aliases that map to existing detector classes
+        alias_tests = {
+            "deepseek-v3": Qwen3Detector,
+            "step3": DeepSeekR1Detector,
+            "step3p5": DeepSeekR1Detector,
+            "interns1": Qwen3Detector,
+        }
+        for model_type, expected_class in alias_tests.items():
+            parser = ReasoningParser(model_type)
+            self.assertIsInstance(
+                parser.detector,
+                expected_class,
+                f"{model_type} should create {expected_class.__name__}",
+            )
+
+    def test_continue_final_message_with_request(self):
+        """Test continue_final_message passes previous content to detector."""
+        from sglang.srt.entrypoints.openai.protocol import (
+            ChatCompletionMessageGenericParam,
+            ChatCompletionMessageUserParam,
+            ChatCompletionRequest,
+        )
+
+        request = ChatCompletionRequest(
+            model="test",
+            messages=[
+                ChatCompletionMessageUserParam(role="user", content="Hi"),
+                ChatCompletionMessageGenericParam(
+                    role="assistant", content="Let me think..."
+                ),
+            ],
+            continue_final_message=True,
+        )
+        parser = ReasoningParser("qwen3", request=request)
+        self.assertTrue(parser.detector.continue_final_message)
+
+    def test_force_nonempty_content_via_chat_template_kwargs(self):
+        """Test that force_nonempty_content is passed via chat_template_kwargs."""
+        from sglang.srt.entrypoints.openai.protocol import (
+            ChatCompletionMessageUserParam,
+            ChatCompletionRequest,
+        )
+
+        request = ChatCompletionRequest(
+            model="test",
+            messages=[
+                ChatCompletionMessageUserParam(role="user", content="Hi"),
+            ],
+            chat_template_kwargs={"force_nonempty_content": True},
+        )
+        parser = ReasoningParser("nemotron_3", request=request)
+        self.assertTrue(parser.detector._force_nonempty_content)
+
+
+class TestContinueFinalMessage(CustomTestCase):
+    """Test continue_final_message mode for BaseReasoningFormatDetector."""
+
+    def test_continue_with_think_start_in_previous(self):
+        """Test that previous_content with <think> sets _in_reasoning=True."""
+        detector = BaseReasoningFormatDetector(
+            "<think>",
+            "</think>",
+            force_reasoning=False,
+            continue_final_message=True,
+            previous_content="<think>some reasoning",
+        )
+        self.assertTrue(detector._in_reasoning)
+        self.assertEqual(detector.previous_count, len("<think>some reasoning"))
+
+    def test_continue_with_think_end_in_previous(self):
+        """Test that previous_content with </think> sets _in_reasoning=False."""
+        detector = BaseReasoningFormatDetector(
+            "<think>",
+            "</think>",
+            force_reasoning=True,
+            continue_final_message=True,
+            previous_content="<think>done</think>normal",
+        )
+        # think_end_token in previous → _in_reasoning = False
+        self.assertFalse(detector._in_reasoning)
+
+    def test_continue_detect_parse_with_end_in_previous(self):
+        """Test detect_and_parse when think_end_token is in previous_content only.
+        This covers the branch where think_end is NOT in current text
+        but IS in previous_content, so output is treated as normal_text."""
+        detector = BaseReasoningFormatDetector(
+            "<think>",
+            "</think>",
+            force_reasoning=True,
+            continue_final_message=True,
+            previous_content="<think>reasoning</think>",
+        )
+        # _in_reasoning is False (think_end in previous)
+        # But force_reasoning was True → detect_and_parse still enters the
+        # reasoning path because think_start is in previous_content.
+        # However, since _in_reasoning=False and no think_start in new text,
+        # it returns normal_text directly.
+        result = detector.detect_and_parse("new content here")
+        self.assertEqual(result.normal_text, "new content here")
+
+    def test_continue_end_in_previous_new_text_has_start_but_no_end(self):
+        """Test: think_end in previous, new text has think_start but no think_end.
+        This produces: in_reasoning=True (from think_start in text),
+        think_end NOT in processed_text, think_end IN previous_content,
+        so it falls through to the else branch that returns normal_text."""
+        detector = BaseReasoningFormatDetector(
+            "<think>",
+            "</think>",
+            force_reasoning=False,
+            continue_final_message=True,
+            previous_content="earlier <think>old</think>old answer",
+        )
+        # _in_reasoning = False (think_end in previous overrides)
+        self.assertFalse(detector._in_reasoning)
+        # New text has <think> (triggers in_reasoning) but no </think>
+        # think_end IS in previous_content → skips the truncated-reasoning branch
+        # think_end NOT in processed_text → falls to else that returns normal_text
+        result = detector.detect_and_parse("<think>continuing reasoning")
+        self.assertEqual(result.normal_text, "continuing reasoning")
+        self.assertEqual(result.reasoning_text, "")
+
+    def test_continue_detect_parse_think_start_in_prev_but_end_also_in_prev(self):
+        """Test detect_and_parse where both think tokens are in previous,
+        and new text contains <think> to re-enter reasoning."""
+        detector = BaseReasoningFormatDetector(
+            "<think>",
+            "</think>",
+            force_reasoning=False,
+            continue_final_message=True,
+            previous_content="<think>old reasoning</think>old answer",
+        )
+        # _in_reasoning = False (end token in previous overrides start)
+        self.assertFalse(detector._in_reasoning)
+        # New text starts a fresh reasoning block
+        result = detector.detect_and_parse("<think>new reasoning</think>new answer")
+        self.assertEqual(result.reasoning_text, "new reasoning")
+        self.assertEqual(result.normal_text, "new answer")
+
+    def test_streaming_returns_empty_when_in_reasoning_and_end_buffered(self):
+        """Test that streaming returns empty when buffer could be partial end token."""
+        detector = BaseReasoningFormatDetector(
+            "<think>", "</think>", force_reasoning=True, stream_reasoning=True
+        )
+        # In reasoning mode, send partial end token
+        result = detector.parse_streaming_increment("</")
+        self.assertEqual(result.reasoning_text, "")
+        self.assertEqual(result.normal_text, "")
+        # This goes through the path where _in_reasoning is True but buffer
+        # is a prefix of think_end_token → returns empty
+
+
+class TestGptOssDetectorToolCall(CustomTestCase):
+    """Test GptOssDetector tool_call raw_text handling."""
+
+    def test_detect_and_parse_tool_call_raw_text(self):
+        """Test that tool_call events use raw_text when available."""
+        from sglang.srt.parser.reasoning_parser import GptOssDetector
+
+        detector = GptOssDetector()
+        # Sequence with CALL...RETURN that produces tool_call events with raw_text
+        text = (
+            "<|start|><|channel|>analysis<|message|>think<|end|>"
+            "<|call|>function_data<|return|>"
+            "<|channel|>final<|message|>result<|end|>"
+        )
+        result = detector.detect_and_parse(text)
+        self.assertIn("think", result.reasoning_text)
+        # Tool call raw_text and/or final result should be in normal_text
+        self.assertIn("result", result.normal_text)
+
+    def test_streaming_tool_call_raw_text(self):
+        """Test streaming parse with tool_call events preserving raw_text."""
+        from sglang.srt.parser.reasoning_parser import GptOssDetector
+
+        detector = GptOssDetector()
+        chunks = [
+            "<|start|><|channel|>analysis<|message|>reason<|end|>",
+            "<|call|>tool_payload<|return|>",
+            "<|channel|>final<|message|>done<|end|>",
+        ]
+        all_reasoning = ""
+        all_normal = ""
+        for chunk in chunks:
+            result = detector.parse_streaming_increment(chunk)
+            all_reasoning += result.reasoning_text
+            all_normal += result.normal_text
+        self.assertIn("reason", all_reasoning)
+        self.assertIn("done", all_normal)
+
+
 if __name__ == "__main__":
     unittest.main()